① java_集合框架1
二百分都不给你写~ 这是一堆不是一个问题。虽然很基础，但浪费时间。
② JAVA集合框架 试题
/*1： 假如有以下email数据“[email protected],[email protected],[email protected],..”
* 现需要把email中的用户部分和邮件地址部分分离，
* 分离后以键值对应的方式放入HashMap？
*/
String[] emails={"[email protected]","[email protected]","[email protected]"};
Map<String, String> emailsMap=new HashMap<String, String>();
for (int i = 0; i < emails.length; i++) {
String email=emails[i];//获取单个邮箱
String qian=email.substring(0, email.indexOf('@'));//截取用户
String hou=email.substring(email.indexOf('@'));//截取地址
emailsMap.put(qian, hou);//放入集合
}
/**
* 2： 产生一组班级对象，并放入集合ArrayList对象中？
* */
banJi a=new banJi("优化班",56);//生成两个班级对象
banJi b=new banJi("普通班",35);
List<banJi> banJis=new ArrayList<banJi>();//创建一个ArrayList集合
banJis.add(a);//将两个班级放入集合中
banJis.add(b);
③ java集合框架问题...
你输入的是map的key值，这句话就是根据key值取出map里的student对象，并赋给你定义的student，就是for循环里定义的student。
④ java常用框架面试题
1、什么是Spring?
Spring是个Java企业级应用的开源开发框架。Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。Spring框架目标是简化Java企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。
2、Spring框架有哪些不同的模块?
核心容器模块、应用上下文模块Application context、AOP模块、JDBC抽象和DAO模块、O/R映射整合模块、Web模块、MVC框架模块。
3、一个简单的Spring应用程序包括什么?
这些应用程序像任何Java应用程序。它们是由多个类组成，每个类执行应用程序内的一个特定的功能。这些类的配置是通过一个XML文件向对方导入依赖。此XML文件描述如何配置类，称为Spring配置文件。
4、如何给Spring容器提供配置元数据?
有三种重要的方法给Spring 容器提供配置元数据：XML配置文件、基于注解的配置、基于Java的配置。
5、在Spring中如何注入一个Java集合?
Spring提供以下几种集合的配置元素：
类型用于注入一列值，允许有相同的值。
类型用于注入一组值，不允许有相同的值。
类型用于注入一组键值对，键和值都可以为任意类型。
类型用于注入一组键值对，键和值都只能为String类型。
6、在Spring框架中如何更有效地使用JDBC?
使用Spring JDBC框架，资源管理和错误处理的代价都会被减轻。所以开发者只需statements和queries从数据存取数据，JDBC也可以在Spring框架提供的模板类的帮助下更有效地被使用，这个模板叫JDBC Template 。
7、如何通过HibernateDaoSupport将Spring和Hibernate结合起来?
用Spring的SessionFactory调用LocalSessionFactory。集成过程分三步：
配置the Hibernate Session Factory、继承HibernateDaoSupport实现一个DAO、在AOP支持的事务中装配。
8、解释一下Spring MVC框架及其控制器
Spring配备构建Web应用的全功能MVC框架。Spring可以很便捷地和其他MVC框架集成，如Struts、Spring的MVC框架用控制反转把业务对象和控制逻辑清晰地隔离。它也允许以声明的方式把请求参数和业务对象绑定。
控制器提供一个访问应用程序的行为，此行为通常通过服务接口实现。控制器解析用户输入并将其转换为一个由视图呈现给用户的模型。Spring用一个非常抽象的方式实现了一个控制层，允许用户创建多种用途的控制器。
⑤ 请java人员帮个忙！关于集合框架的一个程序！
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class MedalRank {
public static void main(String[] args) {
Country c1 = new Country("China",100,80,100);
Country c2 = new Country("American",10,100,10);
Country c3 = new Country("Japan",50,50,50);
List<Country> list = new ArrayList<Country>();
list.add(c1);
list.add(c2);
list.add(c3);
//金牌榜
Collections.sort(list, new GoldComparator());
System.out.println("\r\nGold medal Rank as follow:");
for(Country c : list) {
System.out.println(c.name);
}
//银牌榜
Collections.sort(list, new SilverComparator());
System.out.println("\r\nSilver medal Rank as follow:");
for(Country c : list) {
System.out.println(c.name);
}
//铜牌榜
Collections.sort(list, new CopperComparator());
System.out.println("\r\nCopper medal Rank as follow:");
for(Country c : list) {
System.out.println(c.name);
}
}
}
class GoldComparator implements Comparator<Country> {
@Override
public int compare(Country c1, Country c2) {
return c2.gold - c1.gold;
}
}
class SilverComparator implements Comparator<Country> {
@Override
public int compare(Country c1, Country c2) {
return c2.silver - c1.silver;
}
}
class CopperComparator implements Comparator<Country> {
@Override
public int compare(Country c1, Country c2) {
return c2.copper - c1.copper;
}
}
⑥ Java集合框架2
根据你上面的提示和程序里的要求，修改了Database，新增了衣服的方法。每次计算的价格可以写成共通方法。希望其他人有好的建议也发上来。
import java.util.HashMap;
import java.util.Map;
public class Database {
private Map<Integer, McBean> data = new HashMap<Integer, McBean>();
public Database(){
McBean bean = new McBean();
bean.setNid(1);
bean.setSname("地瓜");
bean.setNprice(2.0);
bean.setSdescription("新鲜的地瓜");
data.put(1, bean);
bean = new McBean();
bean.setNid(2);
bean.setSname("薯仔");
bean.setNprice(1.2);
bean.setSdescription("又好又大的薯仔");
data.put(2, bean);
bean = new McBean();
bean.setNid(3);
bean.setSname("丝瓜");
bean.setNprice(1.5);
bean.setSdescription("本地丝瓜");
data.put(3, bean);
bean = new McBean();
bean.setNid(4);
bean.setSname("衣服");
bean.setNprice(30);
bean.setSdescription("衣服");
data.put(4, bean);
}
public McBean getMcBean(int nid){
return data.get(nid);
}
}
public class McBean {
private Integer nid; //商品编号
private String sname; //名称
private double nprice; //价格
private String sdescription; //描述
public Integer getNid() {
return nid;
}
public void setNid(Integer nid) {
this.nid = nid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public double getNprice() {
return nprice;
}
public void setNprice(double nprice) {
this.nprice = nprice;
}
public String getSdescription() {
return sdescription;
}
public void setSdescription(String sdescription) {
this.sdescription = sdescription;
}
}
public class OrderItemBean {
private McBean mcbean; //商品
private int count; //商品数量
public McBean getMcbean() {
return mcbean;
}
public void setMcbean(McBean mcbean) {
this.mcbean = mcbean;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class ShoppingCar {
private double totalPrice; //购物车所有商品总价格
private int totalCount; //购物车所有商品数量
private Map<Integer,OrderItemBean> itemMap; //商品编号与订单项的键值对
public ShoppingCar(){
//初始化购物车
itemMap = new HashMap<Integer, OrderItemBean>();
Database db = new Database();
McBean bean = new McBean();
OrderItemBean orderItem1 = new OrderItemBean();
OrderItemBean orderItem2 = new OrderItemBean();
OrderItemBean orderItem3 = new OrderItemBean();
bean = db.getMcBean(1);
orderItem1.setMcbean(bean);
orderItem1.setCount(2);
bean = db.getMcBean(2);
orderItem2.setMcbean(bean);
orderItem2.setCount(5);
bean = db.getMcBean(4);
orderItem3.setMcbean(bean);
orderItem3.setCount(3);
itemMap.put(1, orderItem1);
itemMap.put(2, orderItem2);
itemMap.put(4, orderItem3);
totalCount = itemMap.size();
totalPrice = 0;
Set set = itemMap.entrySet();
Iterator i = set.iterator();
while(i.hasNext()){
Map.Entry<Integer, OrderItemBean> entry1=(Map.Entry<Integer, OrderItemBean>)i.next();
totalPrice += entry1.getValue().getCount() * entry1.getValue().getMcbean().getNprice();
}
}
public void buy(int nid){
//如果该商品是第一次购买，商品的信息从数据库获取，数据库的模拟代
//码见附录。itemMap增加一对键值对。
//如果不是第一次购买，则通过商品编号找到对应的定单项，然后更新定
//单项的商品数量。
//不管是否第一次购买，都得更新购物车的总价格和总数量。
Database db = new Database();
McBean mcBean = new McBean();
OrderItemBean orderItem = new OrderItemBean();
if(itemMap.get(nid) == null) {
mcBean = db.getMcBean(nid);
orderItem.setMcbean(mcBean);
orderItem.setCount(1);
itemMap.put(nid, orderItem);
} else {
orderItem = itemMap.get(nid);
orderItem.setCount(orderItem.getCount() + 1);
}
totalCount = itemMap.size();
totalPrice = 0;
Set set = itemMap.entrySet();
Iterator i = set.iterator();
while(i.hasNext()){
Map.Entry<Integer, OrderItemBean> entry1=(Map.Entry<Integer, OrderItemBean>)i.next();
totalPrice += entry1.getValue().getCount() * entry1.getValue().getMcbean().getNprice();
}
}
public void delete(int nid){
//通过商品编号删除的对应的定单项，然后从更新购物车的总价格和总数量。
itemMap.remove(nid);
totalCount = itemMap.size();
totalPrice = 0;
Set set = itemMap.entrySet();
Iterator i = set.iterator();
while(i.hasNext()){
Map.Entry<Integer, OrderItemBean> entry1=(Map.Entry<Integer, OrderItemBean>)i.next();
totalPrice += entry1.getValue().getCount() * entry1.getValue().getMcbean().getNprice();
}
}
public void update(int nid, int count){
///通过商品编号找到对应的对应的定单项，修改商品数量。然后从更新购物车的总价格和总数量。
OrderItemBean orderItem = new OrderItemBean();
orderItem = itemMap.get(nid);
orderItem.setCount(count);
totalCount = itemMap.size();
totalPrice = 0;
Set set = itemMap.entrySet();
Iterator i = set.iterator();
while(i.hasNext()){
Map.Entry<Integer, OrderItemBean> entry1=(Map.Entry<Integer, OrderItemBean>)i.next();
totalPrice += entry1.getValue().getCount() * entry1.getValue().getMcbean().getNprice();
}
}
public void clear(){
//清空定单项，购物车的总价格和总数量清零。
itemMap.clear();
totalCount = 0;
totalPrice = 0;
}
public void show(){
//显示购物车的商品，格式如下:
//商品编号 商品名称 单价 购买数量 总价
//1 地瓜 2.0 2 4.0
//2 衣服 30 5 150
//…
//合计：总数量：5 总价格：20元
System.out.println("商品编号" + " " + "商品名称" + " " + "单价" + " " + "购买数量" + " " + "总价" );
Set set = itemMap.entrySet();
Iterator i = set.iterator();
while(i.hasNext()){
Map.Entry<Integer, OrderItemBean> entry1=(Map.Entry<Integer, OrderItemBean>)i.next();
int nid = entry1.getKey();
String name = entry1.getValue().getMcbean().getSname();
double price = entry1.getValue().getMcbean().getNprice();
int count = entry1.getValue().getCount();
double totalprice = price * count;
System.out.println(nid + " "+ name + " " + price + " " + count + " " + totalprice);
}
System.out.println("合计：总数量：" + totalCount + " 总价格：" + totalPrice+ "元");
}
public static void main(String[] args) {
ShoppingCar shoppingCar = new ShoppingCar();
shoppingCar.show();
System.out.println("--------------------------------");
shoppingCar.buy(3);
shoppingCar.show();
System.out.println("--------------------------------");
shoppingCar.update(4, 2);
shoppingCar.show();
System.out.println("--------------------------------");
shoppingCar.delete(2);
shoppingCar.show();
System.out.println("--------------------------------");
shoppingCar.clear();
shoppingCar.show();
}
}
运行结果：
商品编号 商品名称 单价 购买数量 总价
1 地瓜 2.0 2 4.0
2 薯仔 1.2 5 6.0
4 衣服 30.0 3 90.0
合计：总数量：3 总价格：100.0元
--------------------------------
商品编号 商品名称 单价 购买数量 总价
1 地瓜 2.0 2 4.0
2 薯仔 1.2 5 6.0
3 丝瓜 1.5 1 1.5
4 衣服 30.0 3 90.0
合计：总数量：4 总价格：101.5元
--------------------------------
商品编号 商品名称 单价 购买数量 总价
1 地瓜 2.0 2 4.0
2 薯仔 1.2 5 6.0
3 丝瓜 1.5 1 1.5
4 衣服 30.0 2 60.0
合计：总数量：4 总价格：71.5元
--------------------------------
商品编号 商品名称 单价 购买数量 总价
1 地瓜 2.0 2 4.0
3 丝瓜 1.5 1 1.5
4 衣服 30.0 2 60.0
合计：总数量：3 总价格：65.5元
--------------------------------
商品编号 商品名称 单价 购买数量 总价
合计：总数量：0 总价格：0.0元
⑦ 能熟练的掌握java 的 封装、继续、多态、集合框架的练习题谁有
通过练习题 掌握 封装 继承 多态 这个想法不切合实际，这些都是编程思想，是通过实践得来的
⑧ 高分求java相关练习题，最好是集合框架相关的。
集合类永远都是个最优选择的问题，我可以给你出个题：比较简单的逻辑，只为做练习
1 定义一个Person类，有String-name，int age，和对应的构造方法，getset方法，重写equels方法，规则是name相等
2 建立多个Person类实例，name你就起英文就好，以name字母序排序，得到Person的集合（自己想用都用什么集合类）
3 当俩个人是同一个人（name相等就算一个人，分别new俩个或多个name相等的Person对象），做出一个没有重复人的集合（2里面重复不重复随意，3里面不能重复）
4 遍历2,3集合，输出结果查看
以上是全部的要求，是整个程序的，不是4道题
⑨ java集合框架的小问题
因为HashMap一次次添加在对象内部并不是按照先后顺序添加的,我给你说说结果:
当只加第一个映射时,HashMap的打印结果是:
关键代码:
aa.put("1","java");
System.out.println(aa) ;
结果:
{1=java}
第二次:
aa.put("1","java");
aa.put("2","VB");
System.out.println(aa) ;
结果:
{2=VB, 1=java}
第三次:
aa.put("1","java");
aa.put("2","VB");
aa.put("3","VC++");
结果:
{3=VC++, 2=VB, 1=java}
第四次:
aa.put("1","java");
aa.put("2","VB");
aa.put("3","VC++");
aa.put("4","c++");
结果:
{3=VC++, 2=VB, 4=c++, 1=java}
第五次:
aa.put("1","java");
aa.put("2","VB");
aa.put("3","VC++");
aa.put("4","c++");
aa.put( "5","c");
结果:
{3=VC++, 5=c, 2=VB, 4=c++, 1=java}
第六次:
aa.put("1","java");
aa.put("2","VB");
aa.put("3","VC++");
aa.put("4","c++");
aa.put( "5","c");
aa.put( "6","basic");
结果:
{3=VC++, 5=c, 2=VB, 4=c++, 6=basic, 1=java}
第七次:
aa.put("1","java");
aa.put("2","VB");
aa.put("3","VC++");
aa.put("4","c++");
aa.put( "5","c");
aa.put( "6","basic");
aa.put( "7","Jscript");
结果:
{3=VC++, 5=c, 7=Jscript, 2=VB, 4=c++, 6=basic, 1=java}
由以上结果我们可以看出来,在HashMap里,添加顺序并不是按从前向后的顺序添加的,也不是按从后向前添加的,在HashMap的文挡帮助里有这么一句话:"此类不保证映射的顺序，特别是它不保证该顺序恒久不变。",如果你又想用Map又想保持顺序，可以使用LinkedHashMap,它和HashMap一样，但是可以保证插入顺序，但是这样也增加了一点点开销.
⑩ java集合框架相关练习
要掌握的接口 ：List ，Map List 的实现类： ArrayList（ 遍历集合中元素时