Java各种集合

ArrayList集合
单列集合,底层数组结构,查询快,增删慢,可重复,按照添加的顺序存储输出.
*Collections是用来操作单列集合的工具类

	public static addAll(Collection<? super T> c, T... elements) //往集合中一次添加多个元素
	public static void sort(List<T> list)//对集合进行排序
	public static int binarySearch(List list, T key) // 使用二分查找法，查找List集合中指定元素的索引,使用二分法之前必须先对集合中的元素进行排序
	public static void	swap(List<?> list, int i, int j) //对指定的两个元素的索引相互交换位置
	public static T max(Collection<? extends T> coll) //获取集合中元素的最大值
	public static T min(Collection<? extends T> coll) //获取集合中元素的最小值
	public static void	reverse(List<?> list) //对集合中的元素进行反转
	public static void	shuffle(List<?> list) //对集合中的元素进行随机置换,洗牌

自然排序

 public int compareTo(Student s) {
        int num = this.age-s.age;//升序
        //int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        if (num==0){
            int i = this.name.compareTo(s.name);
            num=i;
        }
        return num;
    }

比较器排序

    Collections.sort(list, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.getAge()-o2.getAge();
                if (num==0){
                    int i = o1.getName().compareTo(o2.getName());
                    num=i;
                }
                return num;
            }
        });

LinkList

LinkList集合地层是链表,查询慢,增删快,
与arraylist集合一样有序,可以重复,多了几种对头尾元素的几种操作方法

HashSet集合

Collection接口
List: 有索引、有序、元素可以重复
ArrayList:数组结构(查询块、增删慢)
LinkedList：链表结构(查询慢、增删快)

Set：
没有索引、无序、元素不能重复
HashSet: 哈希表结构
TreeSet: 红黑树结构
遍历的顺序与添加的顺序不一致,没有索引,不能用普通for循环遍历,只能用增强for循环或者迭代器遍历``

public class Test {
    public static void main(String[] args){
        HashSet hs = new HashSet();
        Student s1 = new Student("张三",15);
        Student s2 = new Student("李四",16);
        Student s3 = new Student("王五",17);
        Student s4 = new Student("张三",15);
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        hs.add(s4);
        System.out.println(s1.hashCode());
        System.out.println(s4.hashCode());
        //s1的哈希值与s4的哈希值不一样,尽管对象的属性值相同,但是s1和s4是两个对象,所以有两个不同的哈希值,所以都能添加到hashset集合中
    }
}

hashset集合保证元素的唯一性原理

1. 计算存储对象的哈希值
2. 当前存储对象与已经存储的对象的哈希值相比较,如果两个对象的哈希值相同的话,就比较两个元素的equals值
3. 比较两个对象的equals值,如果两个对象的哈希值与equals值相同,则认为两个元素是同一个对象
   我们在存储对象的时候,需要在实体类中重写hashset和equals方法以保证元素的唯一性.存储的过程与取出的过程不一致,无序,无索引,元素不重复

TreeSet集合

元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法
TreeSet()：根据其元素的自然排序进行排序
TreeSet(Comparator comparator) ：根据指定的比较器进行排序
没有带索引的方法，所以不能使用普通for循环遍历
由于是Set集合，所以不包含重复元素的集合

存储的String Integer类型的数据都能按照字典顺序排列,应为在String 和Interger类中底层都已经实现了Comparable类,重写了compareTo方法,我们在存储实体类对象的时候就需要实现Comparator接口,根据指定的比较器进行排序

public class Teacher implements Comparable<Teacher>{
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", 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;
    }
    public Teacher(){}
    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Teacher o) {
        int num = this.getAge()-o.age;
        if (num==0){
            int i = this.getName().compareTo(o.name);
            num = i;
        }return num;
    }
}

import java.util.TreeSet;

public class Test {
    public static void main(String[] args){
        TreeSet<Teacher> ts = new TreeSet();
        Teacher t1 = new Teacher("张三",15);
        Teacher t2 = new Teacher("李四",17);
        Teacher t3 = new Teacher("王五",19);
        Teacher t4 = new Teacher("张三",15);
        ts.add(t1);
        ts.add(t2);
        ts.add(t3);
        ts.add(t4);
        for (Teacher t : ts) {
            System.out.println(t);
        }
    }
}
//执行结果,实现Comparable接口重写ToCompara方法
//Teacher{name='张三', age=15}
//Teacher{name='李四', age=17}
//Teacher{name='王五', age=19}

比较器排序

import java.util.Comparator;
import java.util.TreeSet;

public class Test2 {
    public static void main(String[] args){
        TreeSet<Teacher> ts = new TreeSet(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                int num = o1.getAge()-o2.getAge();
                if (num==0){
                    int i = o1.getName().compareTo(o2.getName());
                    num=i;

                }
                return num;
            }
        }) ;

        Teacher t1 = new Teacher("张三",15);
        Teacher t2 = new Teacher("李四",17);
        Teacher t3 = new Teacher("王五",19);
        Teacher t4 = new Teacher("张三",15);
        ts.add(t1);
        ts.add(t2);
        ts.add(t3);
        ts.add(t4);
        for (Object t : ts) {
            System.out.println(t);
        }
    }
}
//结果与上面结果相同

Map集合遍历方法一

//获取所有的键的集合
 Set<String> keys = map.keySet();
 //遍历所有的键
        for (String key : keys) {
        //通过每一个键得到对应的值
            String s = map.get(key);
            System.out.println(key+":"+s);
        }

Map集合遍历方法二

//得到所有的键值对集合
        Set<Map.Entry<String, String>> entries = map.entrySet();
        //遍历所有的键值对集合得到每一个键值对
        for (Map.Entry<String, String> entry : entries) {
//            通过键值对得到对应的键和值
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+":"+value);
        }

统计字符出现的个数

import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
public class Demo {
    public static void main(String[] args){
        HashMap<Character,Integer> hm = new HashMap<>();
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String s = scanner.nextLine();
        for (int i=0;i<s.length();i++){
            char c = s.charAt(i);
            if (hm.containsKey(c)){
                Integer i1 = hm.get(c);
                i1++;
                hm.put(c,i1);
            }else {
                hm.put(c,1);
            }
        }
        Set<Character> chs = hm.keySet();
        for (Character ch : chs) {
            Integer i = hm.get(ch);
            System.out.println(ch+"("+i+")");
        }
    }
}