java：集合基础学习

集合

ArrayList和LinkedList的大致区别

1. ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2. 对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3. 对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   

public class Student implements Comparable<Student>{
    private String name;
    private int age;
    public Student() {}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public int getAge() {return age;}
    public void setAge(int age) {this.age = age;}
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Student student) {
        int num = this.age - student.age;
        int num2 = num==0?this.name.compareTo(student.name):num;
        return num2;
    }
}

import java.util.TreeSet;
public class TreeSetTest {
    public static void main(String[] args) {
        TreeSet<Student> treeSet = new TreeSet<>();
        Student s1 = new Student("wangwu",31);
        Student s2 = new Student("lisi",33);
        Student s3 = new Student("zhangsan",32);
        Student s4 = new Student("zhaosi",35);
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        for(Student s : treeSet){
            System.out.println(s);
        }
    }
}

public class TreeSetDemo {
    public static void main(String[] args) {
        //匿名内部类
        TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });
        Student s1 = new Student("wangwu",31);
        Student s2 = new Student("lisi",33);
        Student s3 = new Student("zhangsan",32);
        Student s4 = new Student("zhaosi",35);
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
    }
}

public class GenericDemo {
    public static void main(String[] args) {
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Integer>();
        List<?> list3 = new ArrayList<String>();

        List<? extends Number> list4 = new ArrayList<Integer>();
        List<? extends Number> list5 = new ArrayList<Float>();

        List<? super Number> list6 = new ArrayList<Object>();
        List<? super Integer> list7 = new ArrayList<Number>();
        List<? super Integer> list8 = new ArrayList<Object>();
    }
}

public class HashMapDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入字符串");
        String line = sc.nextLine();
        //创建集合，键是Character，值是Integer
//        HashMap<Character, Integer> hm = new HashMap<>();
		//对键进行排序
        TreeMap<Character, Integer> hm = new TreeMap<>();
        //遍历字符串，得到每一个字符
        for (int i = 0; i < line.length(); i++) {
            char key = line.charAt(i);
            //拿得到的每一个字符作为键到HashMap集合中去找对应的值，看返回值
            Integer value= hm.get(key);
            //如果返回值是null，说明该字符在HashMap中不存在，就将该字符作为键，1作为值存储
            if(value == null){
                hm.put(key,1);
            }else{
                //如果返回值不是null，说明该字符在HashMap中存在，把该值加1，重新存储该字符和对应的值
                value++;
                hm.put(key,value);
            }
        }
        //遍历集合，得到键和值
        StringBuilder s = new StringBuilder();
        Set<Character> keySet = hm.keySet();
        for(Character key : keySet){
            Integer value = hm.get(key);
            s.append(key).append("(").append(value).append(")");
        }
        String result = s.toString();
        System.out.println(result);
    }
}

• Collection是一个接口，是java集合中的顶级接口之一，衍生出了java集合的庞大的体系，定义了集合对象的基本操作方法。
• Collections则是工具类，是java集合中常用的方法的一个小小汇总，覆盖了排序，搜索，线程安全之类的一些算法，里面基本都是静态方法，可以直接用类名调用。
  

public class PokerDemo {
    public static void main(String[] args) {
        //键是编号，值是牌
        HashMap<Integer, String> hashMap = new HashMap<>();
        //存储编号
        ArrayList<Integer> arrayList = new ArrayList<>();
        String[] colors = {"♦", "♣", "♥", "♠"};
        String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        //从0开始往HashMap里面存储编号，并存储对应的牌，往ArrayList中存储编号
        int index = 0;
        for (String number : numbers) {
            for (String color : colors) {
                hashMap.put(index, color + number);
                arrayList.add(index);
                index++;
            }
        }
        hashMap.put(index, "queen");
        arrayList.add(index);
        index++;
        hashMap.put(index, "king");
        arrayList.add(index);
        //洗牌，洗的是编号
        Collections.shuffle(arrayList);
        //发牌，发的是编号，保证编号是排序的
        TreeSet<Integer> zsSet = new TreeSet<>();
        TreeSet<Integer> lsSet = new TreeSet<>();
        TreeSet<Integer> wwSet = new TreeSet<>();
        TreeSet<Integer> dpSet = new TreeSet<>();
        for (int i = 0; i < arrayList.size(); i++) {
            int x = arrayList.get(i);
            if (i >= arrayList.size() - 3) {
                dpSet.add(x);
            } else if (i % 3 == 0) {
                zsSet.add(x);
            } else if (i % 3 == 1) {
                lsSet.add(x);
            } else if (i % 3 == 2) {
                wwSet.add(x);
            }
        }
        lookPoker("张三", zsSet, hashMap);
        lookPoker("李四", lsSet, hashMap);
        lookPoker("王五", wwSet, hashMap);
        lookPoker("底牌", dpSet, hashMap);
    }
    //发牌方法，获取编号，去HashMap中找对应的牌
    public static void lookPoker(String name, TreeSet<Integer> treeSet, HashMap<Integer, String> hashMap) {
        System.out.print(name + ":");
        for (Integer key : treeSet) {
            String value = hashMap.get(key);
            System.out.print(value + " ");
        }
        System.out.println();
    }
}