java基础--泛型与排序

一. 泛型概念的提出（为什么需要泛型）？

首先，我们看下下面这段简短的代码: 

  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);
    }
    
    
}