Java笔记(Collection集合,Map集合,Collections工具类)

Java笔记(Collection集合,Map集合,Collections工具类) 1.Collection

Collection集合共性方法

        Collection collection =new ArrayList<>();
        collection.add("a");//添加，返回Boolean,添加成功返回true
        collection.remove("a");//删除，返回Boolean,删除成功返回true
        collection.clear();//清空集合
        boolean contains = collection.contains("a");//是否包含“a”这个字符串
        boolean empty = collection.isEmpty();//判断是否为空
        int size = collection.size();//集合长度size；数组长度length
        Object[] objects = collection.toArray();//集合转换数组

1.1 List(有序,有索引,允许重复元素)

包含带索引方法(特有的方法)

 .add()//指定位置添加
 .get()//获取指定位置元素
 .remove()//指定位置移除
 .set()//指定位置替换

list集合3种遍历方式

        //普通for循环
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            System.out.println(s);
        }
        //迭代器
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            String s= iterator.next();
            System.out.println(s);
        }
        //增强for循环
        for (String s : list) {
            System.out.println(s);
        }

1.1.1 ArrayList(底层数组，查询快，增删慢，多线程)

//多态创建集合对象
List list= new ArrayList();

1.1.2 linkedList(底层链表，查询慢，增删快，多线程)

//注意：使用linkedList特有方法，不能使用多态创建对象了
linkedList linkedList = new linkedList();

*** 作首位元素方法(特有的)

//首尾位置 添加
addFirst() <=> push()/ addLast()
//首尾位置 获取
getFirst() / getLast()
//首尾位置 获取
removeFirst()<=>pop() / removeLast()

1.1.3 Vector(底层数组,单线程,1.0版本最早期集合，现在几乎不用了) 1.2 Set(无索引，不包含重复元素)

不能使用普通for循环

set集合存储不重复元素:
前提 : 存储的元素重写hashCode()和equals()方法。
原理 : 在调用add()方法时会先调用hashCode()方法比较地址中是否有这个哈希值，没有–>存储，有（哈希冲突）–>调用再调用euqals()方法比较是否是相同元素，不相同就存，相同就不存

1.2.1 HashSet (哈希表结构，查询速度快，无序)

如果用HashSet 存储自定义类型数据,一定要重写hashCode()和equals()方法,才能保证HashSet集合的去重的特性.

Set set = new HashSet();

1.2.2 linkedHashSet(继承了HashSet，哈希表+链表结构 , 有序)

链表结构是记录元素的存储顺序的,保证了集合的有序

2.Map

Map中的key必须重写hashCode()方法和equals()方法才能保证key的唯一性。

常用方法

//添加
map.put(key,value);//如果key重复了，会出现value值覆盖

//查找
map.get(key);

//删除
map.remove(key);// key存在返回值是value,key不存在放回null

//是否包含指定的key
boolean b = map.containsKey(key);

2.2.1 HashMap(数组+单项链表/哈希表结构, 无序, 多线程, 可有一个null键)

结构:
1.8之前 数组+单项链表 结构
1.8之后 数组+单项链表/红黑树(链表长度超过8之后变成红黑树) 结构

自定义类作为键值

		//自定义类作为vlaue
        Map map = new HashMap<>();
        //自定义类作为key
        Map map = new HashMap<>();

Map集合的遍历方式(Map集合无法直接遍历)

		//方法一: keySet()
        Map map = new HashMap<>();
        //省略map中添加值....
        Set stringSet = map.keySet();//map中所有的key存到set集合中
        //迭代器遍历,也可以通过增强for遍历
        Iterator iterator = stringSet.iterator();//遍历获取每一个key
        while (iterator.hasNext()) {
            String key = iterator.next();
            Object value = map.get(key);//通过key 获取value值
            System.out.println(value);
        }


		//方法二: entrySet()
		Map map = new HashMap<>();
        //省略map中添加值....
        Set> entrySet = map.entrySet();//map中所有的entry对象(键值对对象)存到set集合中
        for (Map.Entry entry : entrySet) {
            String key = entry.getKey();//获取key
            Object value = entry.getValue();//获取value
            System.out.println(key+"和"+value);
        }

2.2.2 linkedHashMap(继承HashMap,哈希表+链表结构，有序)

linkedHashMap linkedHashMap = new linkedHashMap();

2.2.3 Hashtable(几乎不用了,被HashMap取代了)

1.0版本的双列集合,底层是哈希表结构,单线程(线程安全的)
Hashtable键和值都不允许为null

2.2.4 Prooerties(Hashtable集合子类,唯一一个和IO流相结合的集合) 2.2.5 TreeMap 3.Collections(集合工具类) 3.1、Collections.addAll（）往集合中添加所有元素

        ArrayList list = new ArrayList<>();
        Collections.addAll(list,"a","b","c","d","e");//往集合中添加所有元素
        System.out.println(list);

3.2、Collections.shuffle（）随机打乱集合顺序

        ArrayList list = new ArrayList<>();
        Collections.shuffle(list);//随机打乱集合顺序(每次执行集中的元素顺序都不一样)
        System.out.println(list);

3.3、Collections.sort（list）将集合中元素排序(默认升序)，参数只能穿list集合

		//Integer排序：
        ArrayList list = new ArrayList<>();
        Collections.addAll(list,17,3,14,6,10);//往集合中添加所有元素
        Collections.sort(list);//将集合中元素按照升序排序，参数只能穿list集合
        System.out.println(list);
        ____________________________________________________
		//String排序：
		ArrayList list = new ArrayList<>();
        Collections.addAll(list,"d","e","c","a","b");//往集合中添加所有元素
        Collections.sort(list);
        System.out.println(list);
	   ____________________________________________________
		//自定义类型排序(自定义类)
		public class Student implements Comparable {
		    private String name;
		    private int age;
		    //省略了toString/构造/geter/setter等...

		    //重写排序规格
		    @Override
		    public int compareTo(Student o) {
		        return this.getAge()-o.getAge();//按照年龄升序排序
		        //return 0;//默认的return 0;是认为元素都是相同的
		        
		       
		    }
		}

		//业务代码中就可以对这个类排序了.......
		Collections.sort(Student);

3.4、Collections.sort(list, new Comparator()）自定义排序

		//比较自定义类(方法一)
        List list = new ArrayList<>();
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Student o1, Student o2) {
                //按照 int类型 年龄排序-->升序
                int result = o1.getAge()-o2.getAge();
                //如果年龄相同,再使用姓名第一个字 String类型 排序(升序)
                if(result == 0){
                    result = o1.getName().charAt(0)-o2.getName().charAt(0)
                }
                return result;
            }
        });
       ____________________________________________________
		//自定义类型排序(方法二:java8 写法)
		
		List list= new ArrayList<>;// 创建集合
		//日期字符串排序 节次排序(Student属性 bitherday和number 为String类型)
		Comparator comparingDate = Comparator.comparing(Student::getBitherday);
		Comparator comparingNUM = Comparator.comparing(Student::getNumber).reversed();//降序
		// 多个字段联合排序：生日升序,number降序
		list.sort(comparingDate.thenComparing(comparingNUM));

4.Hash值

定义:hash值是一个十进制的整数,由本地系统(native)随机给出(就是对象的地址值,是一个逻辑地址,是模拟出来的地址,不是数据实际存储的物理地址)

.hashCode()//获取hash值

哈希冲突:两个元素不同,但是哈希值相同就是哈希冲突.

哈希表结构查询数据快的原因:
是因为先根据hash值分组了,将hash值相同的元素挂到一个链表上,如果挂载的元素超过8位就将这个链表的结构转换为红黑树.