一. 泛型概念的提出（为什么需要泛型）？
首先，我们看下下面这段简短的代码:
public class GenericTest { public static void main(String[] args) { List list = new ArrayList(); list.add("qqyumidi"); list.add("corn"); list.add(100); for (int i = 0; i < list.size(); i++) { String name = (String) list.get(i); // 1 System.out.println("name:" + name); } } }
在如上的编码过程中，我们发现主要存在两个问题：
1.当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。
2.因此，//1处取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现“java.lang.ClassCastException”异常。
二.什么是泛型？
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此 时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。
泛型的定义：泛型是JDK 1.5的一项新特性，它的本质是参数化类型（Parameterized Type）的应用，也就是说所操作的数据类型被指定为一个参数，在用到的时候在指定具体的类型。这种参数类型可以用在类、 接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法
三.泛型的使用
泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法 注： 没有泛型数组，也没有泛型多态
3.1 泛型类
格式
class 类名<字母列表>{
修饰符 字母 属性；
修饰符 构造器 （字母） {}
修饰符 返回类型 方法名 （字母） {
}
T Type 表示类型。
K V 分别代表键值中的Key Value。
E 代表Element。
注意：
1、泛型只能使用引用类型，不能基本类型
2、在泛型类里，泛型声明时字母不能使用 静态属性|静态方法上，在泛型方法上可以声明在方法上
package com.zwj.fanxing; /** *泛型的擦除 *1、继承|实现声明 不指定类型 *2、使用时 不指定类型 * 统一Object 对待 *1、编译器警告 消除使用Object *2、不完全等同于Object ,编译不会类型检查 * @author Administrator * * @param <T> */ public class Student<T> { private T javaScore; private T oracleScore; //泛型声明时不能使用 静态属性|静态方法上 //private static T1 test; public T getJavaScore() { return javaScore; } public void setJavaScore(T javaScore) { this.javaScore = javaScore; } public T getOracleScore() { return oracleScore; } public void setOracleScore(T oracleScore) { this.oracleScore = oracleScore; } /** * @param args */ public static void main(String[] args) { Student stu1 = new Student(); //消除警告 使用 Object Student<Object> stu = new Student<Object>(); //stu.setJavaScore("af"); //以Object对待 test(stu1); //stu1 相当于Object 但是不完全等同Object //擦除，不会类型检查 //test(stu); test1(stu1); test1(stu); } public static void test(Student<Integer> a){ } public static void test1(Student<?> a){ } }
3.2 泛型接口、
i nterface 接口名 <字母列表> {
修饰符 返回类型 方法（方法）；
}
//因为不能使用在静态属性上，更不能用在全局常量上
package com.zwj.fanxing; /** * 接口中 泛型字母只能使用在方法中，不能使用在全局常量中 * @author Administrator * * @param <T> */ public interface Comparator<T> { void compare(T t); }
package com.zwj.fanxing; /** * 泛型接口:与继承同理 * 重写方法随父类而定 * * @param <T> */ public interface package com.zwj.fanxing; /** * 泛型接口:与继承同理 * 重写方法随父类而定 * * @param <T> */ public interface Comparable<T> { void compare(T t); } //声明子类指定具体类型 class Comp implements Comparable<Integer>{ @Override public void compare(Integer t) { // TODO Auto-generated method stub } } //擦除 class Comp1 implements Comparable{ @Override public void compare(Object t) { // TODO Auto-generated method stub } } //父类擦除，子类泛型 class Comp2<T> implements Comparable{ @Override public void compare(Object t) { // TODO Auto-generated method stub } } //子类泛型>=父类泛型 class Comp3<T> implements Comparable<T>{ @Override public void compare(T t) { // TODO Auto-generated method stub } } //父类泛型，子类擦除 错误{ void compare(T t); } //声明子类指定具体类型 class Comp implements Comparable<Integer>{ @Override public void compare(Integer t) { // TODO Auto-generated method stub } } //擦除 class Comp1 implements Comparable{ @Override public void compare(Object t) { // TODO Auto-generated method stub } } //父类擦除，子类泛型 class Comp2<T> implements Comparable{ @Override public void compare(Object t) { // TODO Auto-generated method stub } } //子类泛型>=父类泛型 class Comp3<T> implements Comparable<T>{ @Override public void compare(T t) { // TODO Auto-generated method stub } } //父类泛型，子类擦除 错误
3.3泛型方法
修饰符 <字母> 返回类型 方法名（字母）{
}
//注意： 泛型还可以定义在方法中，是否拥有泛型方法，与其所有的类是否泛型没有关系
注：只能访问对象的信息，不能修改信息
package com.zwj.fanxing; import java.io.Closeable; import java.io.IOException; /** * 泛型方法 <> 返回类型前面 * 只能访问对象的信息，不能修改信息 * @author Administrator * */ public class TestMethod { /** * @param args */ public static void main(String[] args) { test("a"); //T -->String } //泛型方法 public static <T> void test(T a){ System.out.println(a); } // extends <= public static <T extends Closeable> void test(T... a){ for(T temp:a){ try { if(null!=temp){ temp.close(); } } catch (IOException e) { e.printStackTrace(); } } } }
3.4 没有泛型多态
通配符
?类型不定，使用时确定类型
?使用:声明类型|声明方法上，不能声明类或使用时
? extends : <= 上限 指定类型 子类或自身
? super :>=下限 指定类型 为自身或父类
package com.zwj.fanxing; //泛型类 public class A<T> { }
package com.zwj.fanxing; public class Fruit { } class Apple extends Fruit{ }
package com.zwj.fanxing; /** * 通配符 * ?类型不定，使用时确定类型 * ?使用:声明类型|声明方法上，不能声明类或使用时 * ? extends : <= 上限 指定类型 子类或自身 * ? super :>=下限 指定类型 为自身或父类 * @author Administrator * */ public class Student<T> { T score; public static void main(String[] args) { Student<?> stu = new Student<String>(); test(new Student<Integer>()); test2(new Student<Apple>()); //test3(new Student<Apple>()); //泛型没有多态 //test4(new Student<Apple>()); // < apple extends fruit Student<? super Fruit> 表示是大于等于fruit test4(new Student<Object>()); test4(new Student<Fruit>()); } public static void test(Student<?> stu){ System.out.println("Student<Integer>()"); } // <= public static void test2(Student<? extends Fruit> stu){ System.out.println("Student<? extends Fruit>"); } //泛型没有多态 public static void test3(Student<Fruit> stu){ System.out.println("Student<Apple>()"); } // < apple extends fruit Student<? super Fruit> 表示是大于等于fruit public static void test4(Student<? super Fruit> stu){ System.out.println("Student<? super Fruit>"); } }
package com.zwj.fanxing; public class Bjsxt <T>{ T stu ; public static void main(String[] args) { //泛型的嵌套 Bjsxt<Student<String>> room =new Bjsxt<Student<String>>(); //从外到内拆分 room.stu = new Student<String>(); Student<String> stu = room.stu; String score =stu.score; System.out.println(score); } }
四. 排序和应用类型排序
package com.zwj.bubble; import java.util.Arrays; /** * 最终版本：考虑存在顺序 * @author Administrator * */ public class BubbleSort { /** * @param args */ public static void main(String[] args) { int[] arr ={1,2,9,3,4}; sort1(arr); System.out.println("==========final============"); arr =new int[]{9,1,2,3,4}; sortFinal(arr); } //第二版本，减少每一趟的次数 public static void sortFinal(int[] arr){ boolean sorted= true; int len =arr.length; for(int j=0;j<len-1;j++){ //趟数 sorted =true; //假定有序 for(int i=0;i<len-1-j;i++){ //次数 if(arr[i]>arr[i+1]){ int temp = arr[i]; arr[i] =arr[i+1]; arr[i+1] =temp; sorted =false; //假定失败 } System.out.println(Arrays.toString(arr)); } if(sorted){ //减少趟数 break; } } } //第二版本，减少每一趟的次数 public static void sort1(int[] arr){ int len =arr.length; for(int j=0;j<len-1;j++){ //趟数 System.out.println("第"+(j+1)+"趟"); for(int i=0;i<len-1-j;i++){ //次数 System.out.print("第"+(i+1)+"次"); if(arr[i]>arr[i+1]){ int temp = arr[i]; arr[i] =arr[i+1]; arr[i+1] =temp; } System.out.println(Arrays.toString(arr)); } } } } /*第1趟 第1次[1, 2, 9, 3, 4] 第2次[1, 2, 9, 3, 4] 第3次[1, 2, 3, 9, 4] 第4次[1, 2, 3, 4, 9] 第2趟 第1次[1, 2, 3, 4, 9] 第2次[1, 2, 3, 4, 9] 第3次[1, 2, 3, 4, 9] 第3趟 第1次[1, 2, 3, 4, 9] 第2次[1, 2, 3, 4, 9] 第4趟 第1次[1, 2, 3, 4, 9] ==========final============ [1, 9, 2, 3, 4] [1, 2, 9, 3, 4] [1, 2, 3, 9, 4] [1, 2, 3, 4, 9] [1, 2, 3, 4, 9] [1, 2, 3, 4, 9] [1, 2, 3, 4, 9] */
package com.zwj.innertype; import java.util.Arrays; public class Demo02 { /** * @param args */ public static void main(String[] args) { String[] arr ={"a","abcd","abc","def"}; //从到小排序 降序 boolean sorted= true; int len =arr.length; for(int j=0;j<len-1;j++){ //趟数 sorted =true; //假定有序 for(int i=0;i<len-1-j;i++){ //次数 if(((Comparable)arr[i]).compareTo(arr[i+1])<0){ String temp = arr[i]; arr[i] =arr[i+1]; arr[i+1] =temp; sorted =false; //假定失败 } } if(sorted){ //减少趟数 break; } } System.out.println(Arrays.toString(arr)); } } /* [def, abcd, abc, a]*/
package com.zwj.innertype; import java.util.ArrayList; import java.util.Arrays; import java.util.Date; import java.util.List; public class Demo04 { /** * @param args */ public static void main(String[] args) { Date[] arr =new Date[3]; arr[0] =new Date(); arr[1] =new Date(System.currentTimeMillis()-1000*60*60); arr[2] =new Date(System.currentTimeMillis()+1000*60*60); Utils.sort(arr); //降序 System.out.println(Arrays.toString(arr)); //字符串 String[] arr2 ={"a","abcd","abc","def"}; Utils.sort(arr2); System.out.println(Arrays.toString(arr2)); System.out.println("==========List排序==========="); //存放容器中 List<String> list =new ArrayList<String>(); list.add("a"); list.add("abcd"); list.add("abc"); list.add("def"); Utils.sort(list); System.out.println(list); System.out.println("==========使用Comparator 排序数组==============="); arr2 =new String[]{"a","abcd","abc","def"}; Utils.sort(arr2,new StringComp()); System.out.println(Arrays.toString(arr2)); System.out.println("==========List排序+比较器==========="); list =new ArrayList<String>(); list.add("a"); list.add("abcd"); list.add("abc"); list.add("def"); Utils.sort(list,new StringComp()); System.out.println(list); } } /* [Sat Nov 18 16:03:15 CST 2017, Sat Nov 18 15:03:15 CST 2017, Sat Nov 18 14:03:15 CST 2017] [def, abcd, abc, a] ==========List排序=========== [def, abcd, abc, a] ==========使用Comparator 排序数组=============== [a, abc, def, abcd] ==========List排序+比较器=========== [a, abc, def, abcd]*/
package com.zwj.innertype; import java.util.ArrayList; import java.util.Collections; import java.util.List; /** * 使用Collections对容器的比较 * 1、 public static <T> void sort(List<T> list, Comparator<? super T> c) * 2、public static <T extends Comparable<? super T>> void sort(List<T> list) * void sort(List<T> list) * @author Administrator * */ public class Demo05 { /** * @param args */ public static void main(String[] args) { List<String> list =new ArrayList<String>(); list.add("a"); list.add("abcd"); list.add("abc"); list.add("def"); Collections.sort(list,new StringComp()); System.out.println(list); list =new ArrayList<String>(); list.add("a"); list.add("abcd"); list.add("abc"); list.add("def"); Collections.sort(list); System.out.println(list); } } /*[abcd, abc, def, a] [a, abc, abcd, def]*/
package com.zwj.innertype; import java.util.Comparator; import java.util.List; /** * 排序 * @author Administrator * */ public class Utils { /** * List的排序+比较器 * @param list * @param com */ public static <T> void sort(List<T> list,Comparator<T> com){ //第一步:转成数组 Object[] arr =list.toArray(); sort(arr,com); //第二步:改变容器中对应的值 for(int i=0;i<arr.length;i++){ list.set(i, (T)(arr[i])); } } /** * 数组的排序 （降序）+Comparator接口 * @param arr */ public static <T> void sort(Object[] arr,Comparator<T> com){ //从大到小排序 降序 boolean sorted= true; int len =arr.length; for(int j=0;j<len-1;j++){ //趟数 sorted =true; //假定有序 for(int i=0;i<len-1-j;i++){ //次数 if(com.compare((T)arr[i], (T)arr[i+1])<0){ Object temp = arr[i]; arr[i] =arr[i+1]; arr[i+1] =temp; sorted =false; //假定失败 } } if(sorted){ //减少趟数 break; } } } /** * 容器排序 (使用泛型方法) */ public static <T extends Comparable<T>> void sort(List<T> list){ //第一步:转成数组 Object[] arr =list.toArray(); sort(arr); //第二步:改变容器中对应的值 for(int i=0;i<arr.length;i++){ list.set(i, (T)(arr[i])); } } /** * 数组排序 (使用泛型方法) */ public static <T extends Comparable<T>> void sort(T[] arr){ //从大到小排序 降序 boolean sorted= true; int len =arr.length; for(int j=0;j<len-1;j++){ //趟数 sorted =true; //假定有序 for(int i=0;i<len-1-j;i++){ //次数 if(((Comparable)arr[i]).compareTo(arr[i+1])<0){ T temp = arr[i]; arr[i] =arr[i+1]; arr[i+1] =temp; sorted =false; //假定失败 } } if(sorted){ //减少趟数 break; } } } /** * 数组的排序 （降序） * @param arr */ public static void sort(Object[] arr){ //从大到小排序 降序 boolean sorted= true; int len =arr.length; for(int j=0;j<len-1;j++){ //趟数 sorted =true; //假定有序 for(int i=0;i<len-1-j;i++){ //次数 if(((Comparable)arr[i]).compareTo(arr[i+1])<0){ Object temp = arr[i]; arr[i] =arr[i+1]; arr[i+1] =temp; sorted =false; //假定失败 } } if(sorted){ //减少趟数 break; } } } }
package com.zwj.innertype; /** * 排序规则的业务类 * @author Administrator * */ public class StringComp implements java.util.Comparator<String>{ /** * 按长度比较大小 * 正数 > * 负数 < * 0 == */ @Override public int compare(String o1, String o2) { int len1 =o1.length(); int len2 =o2.length(); return -(len1-len2); } }
引用类型对象的排序
package com.zwj.reftype; /** * 实体类 * @author Administrator * */ public class Goods { //商品名称 private String name; //价格 private double price; //收藏量 private int fav; public Goods() { // TODO Auto-generated constructor stub } public Goods(String name, double price, int fav) { super(); this.name = name; this.price = price; this.fav = fav; } public String getName() { return name; } public void setName(String name) { this.name = name; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } public int getFav() { return fav; } public void setFav(int fav) { this.fav = fav; } @Override public String toString() { return "商品名:"+name+",收藏量"+this.fav+",价格:"+this.price+" "; } }
package com.zwj.reftype; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class GoodsApp { /** * @param args */ public static void main(String[] args) { List<Goods> list =new ArrayList<Goods>(); list.add(new Goods("老马视频",100,2000)); list.add(new Goods("老高视频",50,2000)); list.add(new Goods("老裴视频",1000,1000)); System.out.println("排序前:"+list); Collections.sort(list,new GoodsPriceComp()); /* * 排序前:[商品名:老马视频,收藏量2000,价格:100.0, 商品名:老高视频,收藏量2000,价格:50.0, 商品名:老裴视频,收藏量1000,价格:1000.0] * 排序后:[商品名:老裴视频,收藏量1000,价格:1000.0, 商品名:老马视频,收藏量2000,价格:100.0, 商品名:老高视频,收藏量2000,价格:50.0] */ //Collections.sort(list,new GoodsFavComp()); /* *排序前:[商品名:老马视频,收藏量2000,价格:100.0 , 商品名:老高视频,收藏量2000,价格:50.0 ,商品名:老裴视频,收藏量1000,价格:1000.0 ] *排序后:[商品名:老裴视频,收藏量1000,价格:1000.0 ,商品名:老马视频,收藏量2000,价格:100.0 , 商品名:老高视频,收藏量2000,价格:50.0 ] */ System.out.println("排序后:"+list); } }
package com.zwj.reftype; /** * 按收藏量排序的业务类 （升序） * @author Administrator * */ public class GoodsFavComp implements java.util.Comparator<Goods> { @Override public int compare(Goods o1, Goods o2) { return o1.getFav()-o2.getFav(); } }
package com.zwj.reftype; /** * 按价格排序的业务类 （降序） * @author Administrator * */ public class GoodsPriceComp implements java.util.Comparator<Goods> { @Override public int compare(Goods o1, Goods o2) { //- 负数 表示降序 默认的是升序 return -(o1.getPrice()-o2.getPrice()>0?1:(o1.getPrice()==o2.getPrice()?0:-1)); } }
新闻类的排序
package com.zwj.reftype; import java.text.SimpleDateFormat; import java.util.Date; /** * 新闻条目实体类 * @author Administrator * */ public class NewsItem implements java.lang.Comparable<NewsItem>{ //标题 private String title; //点击量 private int hits; //时间 private Date pubTime; public NewsItem() { } public NewsItem(String title, int hits, Date pubTime) { super(); this.title = title; this.hits = hits; this.pubTime = pubTime; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public int getHits() { return hits; } public void setHits(int hits) { this.hits = hits; } public Date getPubTime() { return pubTime; } public void setPubTime(Date pubTime) { this.pubTime = pubTime; } //时间降序 +点击量升序+标题降序 @Override public int compareTo(NewsItem o) { int result =0; //比较 时间 result =-this.pubTime.compareTo(o.pubTime); //降序 if(0==result){ //时间相同 //点击量 result =this.hits-o.hits; //升序 if(0==result){ //点击量相同 //标题 result=-this.title.compareTo(o.title);//降序 } } return result; } @Override public String toString() { StringBuilder sb =new StringBuilder(); sb.append("标题:").append(this.title); sb.append(",时间:").append(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(this.pubTime)); sb.append(",点击量:").append(this.hits).append(" "); return sb.toString(); } }
package com.zwj.reftype; import java.util.ArrayList; import java.util.Collections; import java.util.Date; import java.util.List; import com.zwj.innertype.Utils; /** * 使用Collections * @author Administrator * */ public class NewsItemApp { /** * @param args */ public static void main(String[] args) { List<NewsItem> news=new ArrayList<NewsItem>(); news.add(new NewsItem("美国后怕了，逃跑了悲剧了",50,new Date(System.currentTimeMillis()-1000*60*60))); news.add(new NewsItem("中国登上钓鱼岛了，全国欢呼了",100,new Date())); news.add(new NewsItem("小日本终于听话了，泪流满面笑了",60,new Date(System.currentTimeMillis()-1000*60*60))); System.out.println("排序前:"+news); //时间降序 +点击量升序+标题降序 Collections.sort(news); //Utils.sort(news); System.out.println("排序后"+news); } } /*排序前:[标题:美国后怕了，逃跑了悲剧了,时间:2017-11-18 14:40:44,点击量:50 , 标题:中国登上钓鱼岛了，全国欢呼了,时间:2017-11-18 15:40:44,点击量:100 , 标题:小日本终于听话了，泪流满面笑了,时间:2017-11-18 14:40:44,点击量:60 ] 排序后[标题:中国登上钓鱼岛了，全国欢呼了,时间:2017-11-18 15:40:44,点击量:100 , 标题:美国后怕了，逃跑了悲剧了,时间:2017-11-18 14:40:44,点击量:50 , 标题:小日本终于听话了，泪流满面笑了,时间:2017-11-18 14:40:44,点击量:60 ]*/
treeMap和treeSet 排序 引用类型对象
package com.zwj.col; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class Person { private final String name;//名称 private final int handsome;//帅气指数 public Person() { name =null; handsome =0; } public Person(String name, int handsome) { super(); this.name = name; this.handsome = handsome; } public String getName() { return name; } public int getHandsome() { return handsome; } @Override public String toString() { return "姓名:"+this.name+",帅气指数:"+this.handsome+" "; } }
package com.zwj.col; import java.util.Set; import java.util.TreeMap; public class TreeMapDemo { /** * @param args */ public static void main(String[] args) { Person p1 =new Person("您",100); Person p2 =new Person("刘德华",1000); Person p3 =new Person("梁朝伟",1200); Person p4 =new Person("老裴",50); TreeMap<Person,String> map =new TreeMap<Person,String>(new java.util.Comparator<Person>(){ @Override public int compare(Person o1, Person o2) { return -(o1.getHandsome()-o2.getHandsome()); } } ); map.put(p1, "bjsxt"); map.put(p2, "bjsxt"); map.put(p3, "bjsxt"); map.put(p4, "bjsxt"); //查看键 Set<Person> persons =map.keySet(); System.out.println(persons); } } /* [姓名:梁朝伟,帅气指数:1200, 姓名:刘德华,帅气指数:1000, 姓名:您,帅气指数:100, 姓名:老裴,帅气指数:50]*/
package com.zwj.col; import java.util.TreeSet; /** * 提供了 解耦的方式:业务排序类 * @author Administrator * */ public class TreeSetDemo { /** * @param args */ public static void main(String[] args) { Person p1 =new Person("您",100); Person p2 =new Person("刘德华",1000); Person p3 =new Person("梁朝伟",1200); Person p4 =new Person("老裴",50); //依次存放到TreeSet容器中,使用排序的业务类(匿名内部类) TreeSet<Person> persons =new TreeSet<Person>( new java.util.Comparator<Person>(){ @Override public int compare(Person o1, Person o2) { return -(o1.getHandsome()-o2.getHandsome()); } } ); persons.add(p1); //TreeSet 在添加数据时排序 persons.add(p2); persons.add(p3); persons.add(p4); System.out.println(persons); /* //改变数据 p4.setHandsome(100); p4.setName("您"); */ //p4 与p1 内容重复 System.out.println(persons); } } /*[姓名:梁朝伟,帅气指数:1200 , 姓名:刘德华,帅气指数:1000 , 姓名:您,帅气指数:100 , 姓名:老裴,帅气指数:50 ] [姓名:梁朝伟,帅气指数:1200 , 姓名:刘德华,帅气指数:1000 , 姓名:您,帅气指数:100 , 姓名:老裴,帅气指数:50 ] */
package com.zwj.col; public class Worker implements java.lang.Comparable<Worker> { //工种 private String type; //工资 private double salary; public Worker() { // TODO Auto-generated constructor stub } public Worker(String type, double salary) { super(); this.type = type; this.salary = salary; } public String getType() { return type; } public void setType(String type) { this.type = type; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } /** * 按工资升序 */ @Override public int compareTo(Worker o) { return this.salary>o.salary?1:( this.salary==o.salary?0:-1); } @Override public String toString() { return "工种:"+this.type+",工资:"+this.salary+" "; } }
package com.zwj.col; import java.util.TreeMap; public class TreeMapDemo02 { /** * @param args */ public static void main(String[] args) { Worker w1 =new Worker("垃圾回收员",12000); Worker w2 =new Worker("农民工",8000); Worker w3 =new Worker("程序猿",5000); //按工资升序 TreeMap<Worker,String > employees =new TreeMap<Worker,String >(); employees.put(w1,"bjsxt"); employees.put(w2,"bjsxt"); employees.put(w3,"bjsxt"); System.out.println(employees.keySet()); } } /* [工种:程序猿,工资:5000.0, 工种:农民工,工资:8000.0, 工种:垃圾回收员,工资:12000.0]*/
package com.zwj.col; import java.util.TreeSet; /** * 实体类实现Comparable 接口的应用 * @author Administrator * */ public class TreeSetDemo2 { /** * @param args */ public static void main(String[] args) { Worker w1 =new Worker("垃圾回收员",12000); Worker w2 =new Worker("农民工",8000); Worker w3 =new Worker("程序猿",5000); TreeSet<Worker> employees =new TreeSet<Worker>(); employees.add(w1); employees.add(w2); employees.add(w3); System.out.println(employees); } } /*[工种:程序猿,工资:5000.0 , 工种:农民工,工资:8000.0 , 工种:垃圾回收员,工资:12000.0 ] */
collections 模仿欢乐斗地主
package com.zwj.col; import java.util.ArrayList; import java.util.Collections; import java.util.List; /** *1、 binarySearch(List<? extends Comparable<? super T>> list, T key) 容器有序 *2、sort(List<T> list) sort(List<T> list, Comparator<? super T> c) *3、reverse(List<?> list) 4、shuffle(List<?> list) 洗牌 5、swap(List<?> list, int i, int j) * @author Administrator * */ public class CollectionsDemo01 { /** * @param args */ public static void main(String[] args) { List<Integer> cards =new ArrayList<Integer>(); //shuffle 洗牌 模拟斗地主 for(int i=0;i<54;i++){ cards.add(i); } //洗牌 Collections.shuffle(cards) ; //依次发牌 List<Integer> p1 =new ArrayList<Integer>(); List<Integer> p2 =new ArrayList<Integer>(); List<Integer> p3 =new ArrayList<Integer>(); List<Integer> last =new ArrayList<Integer>(); for(int i=0;i<51;i+=3){ p1.add(cards.get(i)); p2.add(cards.get(i+1)); p3.add(cards.get(i+2)); } //最后三张为底牌 last.add(cards.get(51)); last.add(cards.get(52)); last.add(cards.get(53)); System.out.println("第一个人:"+p1); System.out.println("第二个人:"+p2); System.out.println("第三个人:"+p3); System.out.println("底牌为:"+last); test1(); } //反转 public static void test1(){ List<Integer> list =new ArrayList<Integer>(); list.add(1); list.add(3); list.add(2); list.add(4); System.out.println(list); Collections.reverse(list); System.out.println("反转之后"+list); } } /* 第一个人:[8, 42, 7, 34, 26, 6, 17, 40, 35, 51, 52, 50, 44, 12, 11, 25, 39] 第二个人:[27, 2, 0, 37, 29, 9, 23, 49, 20, 32, 14, 19, 48, 21, 45, 24, 3] 第三个人:[1, 30, 43, 4, 10, 47, 5, 36, 22, 33, 18, 15, 38, 53, 31, 28, 41] 底牌为:[46, 13, 16] [1, 3, 2, 4] 反转之后[4, 2, 3, 1] */
this is a cat and that is a mice and where is the food? 统计每个单词出现的次数
package com.zwj.map; public class Letter { private String name; private int count; public Letter() { // TODO Auto-generated constructor stub } public Letter(String name, int count) { super(); this.name = name; this.count = count; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getCount() { return count; } public void setCount(int count) { this.count = count; } }
package com.zwj.map; import java.util.HashMap; import java.util.Map; import java.util.Set; /** * this is a cat and that is a mice and where is the food? * 统计每个单词出现的次数 * * 存储到Map中 * key :String * value:自定义类型 * * "分拣" 思路 * 1、为所有key创建容器 * 之后容器中存放对应value * 2、第一次创建容器，并存放值value * 第二次之后，直接使用容器存放值 * @author Administrator * */ public class Demo01 { /** * @param args */ public static void main(String[] args) { String str ="this is a cat and that is a mice and where is the food"; //分割字符串 String[] strArray=str.split(" "); //存储到Map中 Map<String,Letter> letters = new HashMap<String,Letter>(); for(String temp:strArray){ /* //1、为所有key创建容器 if(!letters.containsKey(temp)){ Letter col = new Letter(); col.setCount(1); //第一次值存放容器中 letters.put(temp, col); }else{ //2、 第二次之后，直接使用容器存放值 Letter col =letters.get(temp); //直接使用容器 col.setCount(col.getCount()+1); }*/ Letter col = null; if(null==(col=letters.get(temp))){ col = new Letter(); col.setCount(1); //第一次值存放容器中 letters.put(temp, col); }else{ //2、 第二次之后，直接使用容器存放值 col.setCount(col.getCount()+1); } } //输出Map的值 Set<String> keys = letters.keySet(); for(String key:keys){ Letter col =letters.get(key); System.out.println("字母:"+key+",次数"+col.getCount()); } /*字母:mice,次数1 字母:that,次数1 字母:cat,次数1 字母:is,次数3 字母:food,次数1 字母:a,次数2 字母:the,次数1 字母:where,次数1 字母:this,次数1 字母:and,次数2*/ } public static void test1(){ String str ="this is a cat and that is a mice and where is the food"; //分割字符串 String[] strArray=str.split(" "); //存储到Map中 Map<String,Letter> letters = new HashMap<String,Letter>(); /* for(String temp:strArray){ //1、为所有key创建容器 之后容器中存放对应value if(!letters.containsKey(temp)){ letters.put(temp, new Letter()); } } for(String temp:strArray){ // 容器中存放对应value Letter col =letters.get(temp); //直接使用容器 col.setCount(col.getCount()+1); } */ for(String temp:strArray){ //1、为所有key创建容器 if(!letters.containsKey(temp)){ letters.put(temp, new Letter()); } //2、 之后容器中存放对应value Letter col =letters.get(temp); //直接使用容器 col.setCount(col.getCount()+1); } //输出Map的值 Set<String> keys = letters.keySet(); for(String key:keys){ Letter col =letters.get(key); System.out.println("字母:"+key+",次数"+col.getCount()); } } }
定义一个Student类,属性:name 姓名,classNumber 班号,score 成绩,现在将若干Student对象放入List,请统计出每个班级的总分和平均分,分别打印出来
package com.zwj.map; import java.util.ArrayList; import java.util.List; /** * 班级 * @author Administrator * */ public class ClassRoom { private String no; private List<Student> stus; //学生列表 private double total; //总分 public ClassRoom() { stus = new ArrayList<Student>(); } public ClassRoom(String no) { this(); this.no = no; } public String getNo() { return no; } public void setNo(String no) { this.no = no; } public List<Student> getStus() { return stus; } public void setStus(List<Student> stus) { this.stus = stus; } public double getTotal() { return total; } public void setTotal(double total) { this.total = total; } }
package com.zwj.map; public class Student { private String name; private String no; private double score; public Student() { } public Student(String name, String no, double score) { super(); this.name = name; this.no = no; this.score = score; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getNo() { return no; } public void setNo(String no) { this.no = no; } public double getScore() { return score; } public void setScore(double score) { this.score = score; } @Override public String toString() { return "Student [name=" + name + ", no=" + no + ", score=" + score + "]"; } }
package com.zwj.map; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; /** * 定义一个Student类,属性:name 姓名,classNumber 班号,score 成绩 现在将若干Student对象放入List,请统计出每个班级的总分和平均分,分别打印出来 以面向对象的思维解决 * @author Administrator * */ public class MapDemo03 { public static void main(String[] args) { List<Student> list = new ArrayList<Student>(); exam(list); //统计 Map<String,ClassRoom> rooms = new HashMap<String,ClassRoom>(); count(rooms,list); //打印 printScore(rooms); /*班号为:001,总分160.0,平均分80.0 班号为:002,总分80.0,平均分80.0 班号为:003,总分160.0,平均分80.0*/ } /** * 打印 总分与平均分 */ public static void printScore(Map<String,ClassRoom> rooms){ Set<Map.Entry<String,ClassRoom>> entrySet =rooms.entrySet(); Iterator<Map.Entry<String,ClassRoom>> it =entrySet.iterator(); while(it.hasNext()){ Map.Entry<String,ClassRoom> entry =it.next(); ClassRoom room = entry.getValue(); double avg = room.getTotal()/room.getStus().size(); System.out.println("班号为:"+room.getNo()+",总分"+room.getTotal()+",平均分"+avg); } } /** * 统计分数 */ public static void count(Map<String,ClassRoom> rooms,List<Student> list){ for(Student stu:list){ String no = stu.getNo(); double score = stu.getScore(); //根据班级编号 查看 Map是否存在该班级 分拣思路 ClassRoom room = rooms.get(no); if(null==room){ //第一次 room = new ClassRoom(no); rooms.put(no, room); } //存储 总分 room.setTotal(room.getTotal()+score); room.getStus().add(stu); //加入学生 } } /** * 现在将若干Student对象放入List * @param list */ public static void exam(List<Student> list){ list.add(new Student("a","001",80)); list.add(new Student("b","001",80)); list.add(new Student("a","002",80)); list.add(new Student("c","003",80)); list.add(new Student("d","003",80)); } }
使用自定义类型 接收签名:从界面上接收 到会人员的名单 放入 HashSet中点名:遍历输出名单
package com.zwj.set; import java.text.SimpleDateFormat; import java.util.Date; import java.util.HashSet; import java.util.Iterator; import java.util.Scanner; import java.util.Set; /** * 使用自定义类型 接收签名:从界面上接收 到会人员的名单 放入 HashSet中 点名:遍历输出名单 * @author Administrator * */ public class SetDemo04 { private Scanner sc ; private Set<Member> members; SetDemo04(){ sc = new Scanner(System.in); members= new HashSet<Member>(); } public String getStringFromConsole(){ return sc.nextLine(); } //签名: public void addMemeber(Member mem){ members.add(mem); } //点名:遍历输出名单 public void showMemeber(){ Iterator<Member> it = members.iterator(); while(it.hasNext()){ System.out.println(it.next()); } } /** * @param args */ public static void main(String[] args) { SetDemo04 demo = new SetDemo04(); System.out.println("====签名======"); while(true){ String name =demo.getStringFromConsole(); if(name.equalsIgnoreCase("over")){ break; } Member m =new Member(name); demo.addMemeber(m); } System.out.println("=========参会人员有===="); demo.showMemeber(); /*====签名====== in am me over =========参会人员有==== 名单:me,签名时间:2017-11-18 18:00:39 名单:am,签名时间:2017-11-18 18:00:36 名单:in,签名时间:2017-11-18 18:00:33 */ } } class Member{ private String name; private Date attendTime; public Member() { attendTime = new Date(); } public Member(String name) { this(); this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Date getAttendTime() { return attendTime; } public void setAttendTime(Date attendTime) { this.attendTime = attendTime; } public Member(String name, Date attendTime) { super(); this.name = name; this.attendTime = attendTime; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((name == null) ? 0 : name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Member other = (Member) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } @Override public String toString() { return "名单:"+name+",签名时间:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(attendTime); } }