20220409java第二阶段------集合

集合框架

什么是集合

集合与数组一样，可以保存一组元素，并且提供了操作元素的相关方法，使用方便

集合只能存放引用类型元素，并且存放的是元素的引用（地址）

java集合框架相关接口

java.until.Collection接口：

java.util.Collection是所有集合的顶级接口.Collection下面有多种实现类,因此我们有更多的数据结构可供选择.

Collection下面有两个常见的子接口:

List:线性表是可重复集合，并且有序

Set：不可重复的集合，大部分实现是无序的

注：这里重复指的是集合中的元素是否可以重复，而判定重复元素的标准依靠元素自身equals比较结果，true为重复元素

集合方法

size():集合的元素个数

isEmpty():判断当前集合是否为空集

contains（object o）：判断当前元素给定元素

remove(object o):用来删除给定集合元素

containsAll(Collecton c):判断当前集合是否包含给定集合中的所有元素

removeAll(Collection c):删除当前集合中与给定集合中的所有共有元素

addAll(Collection c):将给定集合中所有元素添加到当前集合中。

 集合的遍历

Collection提供了统一的遍历集合方式:迭代器模式

Iterator iterator()

该方法会获取一个用于遍历当前集合元素的迭代器.，

迭代器也支持泛型，指定的与其遍历的集合指定的泛型一致即可

java.util.Iterator接口

迭代器接口,定义了迭代器遍历集合的相关操作.

不同的集合都实现了一个用于遍历自身元素的迭代器实现类,我们无需记住它们的名字,用多态的角度把他们看做为Iterator即可.

迭代器遍历集合遵循的步骤为:问,取,删.其中删除元素不是必要操作

迭代器的使用：

Collection c=new ArrayList();

c.add("one");

c.add("two");

c.add("three");

//创建迭代器

Iterator it=c.iterator();

while(it.hasNext()){

String str=(String)it.next();//获取集合下一个元素，第一个调用获取第一个元素

System.out.println(str);

}

迭代器要求在遍历过程中不得通过集合的方法增删元素，否则会抛出异常： ConcurrentModificationException，

迭代器的remove方法可以将通过next方法获取的元素从集合中删除，

it.remove();

增强型for循环

语法：

for（元素类型 变量名：集合或数组）{

循环体

}

泛型

泛型也称为参数化类型,允许我们在使用一个类时指定它当中属性,方法参数或返回值的类型.

• 泛型在集合中被广泛使用,用来指定集合中的元素类型.
• 有泛型支持的类在使用时若不指定泛型的具体类型则默认为原型Object

 List集

java.util.List接口,继承自Collection.

List集合是可重复集,并且有序,提供了一套可以通过下标操作元素的方法

常用实现类:

• java.util.ArrayList:内部使用数组实现,查询性能更好.
• java.util.LinkedList:内部使用链表实现,首尾增删元素性能更好.

List集合常见的方法 ：

 E get(int index)：   获取指定下标对应的元素

E set(int index,E e)：将给定元素设置到指定位置，返回值为该位置原有的元素。 替换元素操作

void add(int index,E e)： 将给定元素插入到指定位置

 E remove(int index)：   删除并返回指定位置上的元素

List subList(int start,int end)： 获取当前集合中指定范围内的子集。两个参数为开始与结束的下标(含头不含尾)

clear(); 删除集合

注： 对子集元素的操作就是对原集合对应元素的操作

集合与数组的转换

集合转换为数组

 Object[] array = list.toArray();
            重载的toArray方法要求传入一个数组，内部会将集合所有元素存入该数组
            后将其返回（前提是该数组长度>=集合的size）。如果给定的数组长度不足，
            则方法内部会自行根据给定数组类型创建一个与集合size一致长度的数组并
            将集合元素存入后返回。

 数组转换为list集合

数组的工具类Arrays提供了一个静态方法asList(),可以将一个数组转换为一个List集合

集合的排序

java.util.Collections类

Collections是集合的工具类,里面定义了很多静态方法用于操作集合.

Collections.sort(List list)方法

可以对List集合进行自然排序(从小到大)

Collections.shuffle(list);//乱序

排序自定义类型元素

 Collections.sort(List list)该方法要求集合中的元素类型必须实现接口:
            Comparable,该接口中有一个抽象方法compareTo,这个方法用来定义元素之间比较
            大小的规则.所以只有实现了该接口的元素才能利用这个方法比较出大小进而实现排序
            操作.

实际开发中,我们并不会让我们自己定义的类(如果该类作为集合元素使用)去实现Comparable接口,因为这对我们的程序有侵入性.

侵入性:当我们调用某个API功能时,其要求我们为其修改其他额外的代码,这个现象就是侵入性.侵入性越强的API越不利于程序的后期可维护性.应当尽量避免

重载的Collections.sort(List list,Comparator c)方法

   //匿名内部类的形式创建一个比较器
        Comparator<Point> com = new Comparator<Point>() {
            @Override
            /**
             * 实现比较器接口后必须重写方法compare.
             * 该方法用来定义参数o1与参数o2的比较大小规则
             * 返回值用来表示o1与o2的大小关系
             */
            public int compare(Point o1, Point o2) {
                int len1 = o1.getX() * o1.getX() + o1.getY() * o1.getY();
                int len2 = o2.getX() * o2.getX() + o2.getY() * o2.getY();
                return len1-len2;
            }
        };
        Collections.sort(list,com);//回调模式



        System.out.println(list);

 最终没有侵入性的写法

  Collections.sort(list,(o1,o2)->
                o1.getX() * o1.getX() + o1.getY() * o1.getY() -
                o2.getX() * o2.getX() - o2.getY() * o2.getY()
        );

        System.out.println(list);

 排序字符串

package collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class SortListDemo3 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        list.add("传奇");
        list.add("小泽老师");
        list.add("苍老师");
        System.out.println(list);
        
        //按照字符多少排序

      Collections.sort(list,(o1,o2)->o2.length()-o1.length());
        System.out.println(list);
    }
}

Map 

java.util.Map 接口
Map称为查找表，体现的结构是一个多行两列的表格。其中左列称为key,右列称为value.
Map总是根据key获取对应的value。

常用实现类:
java.util.HashMap:称为散列表，哈希表。是使用散列算法实现的Map，当今查询速度最快的
                  数据结构
java.util.TreeMap:使用二叉树算法实现的Map

Map常见方法

V put(K k,V v)
将一组键值对存入Map中。
Map要求key不允许重复。
如果put方法存入的键值对中，key不存在时，则直接将key-value存入，返回值为null
如果key存在，则是替换value操作，此时返回值为被替换的value
V get(Object k)
根据给定的key获取对应的value，如果给定的key不存在，则返回值为null
map.containsKey
 map.containsValue
可判断Map是否包含给定的key或value
V remove(Object key)
从map中删除给定的key对应的这一组键值对。返回值为该key对应的value

Map的遍历

 Map提供了三种遍历方式:
1:遍历所有的key
2:遍历每一组键值对
3:遍历所有的value(该操作不常用)

public class MapDemo2 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();
        map.put("语文",99);
        map.put("数学",98);
        map.put("英语",97);
        map.put("物理",96);
        map.put("化学",99);
        System.out.println(map);
        /*
            Set keySet()
            将当前Map中所有的key以一个Set集合形式返回，遍历该集合等同于遍历所有的key
         */
        Set<String> keySet = map.keySet();
        for(String key : keySet){
            System.out.println("key:"+key);
        }

        /*
            Set entrySet()
            将当前Map中每一组键值对以一个Entry实例形式表示，并存入Set集合后返回
            java.util.Map.Entry的每一个实例用于表示Map中的一组键值对，其中方法:
            K getKey():获取对应的key
            V getValue():获取对应的value
         */
        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
        for(Map.Entry<String,Integer> e : entrySet){
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key+":"+value);
        }

        /*
            Collection values()
            将当前Map中所有的value以一个集合形式返回
         */
        Collection<Integer> values = map.values();
        for(Integer value : values){
            System.out.println("value:"+value);
        }
    }
}

集合和Map都提供了支持使用lambda表达式遍历的操作

public class ForeachDemo {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        System.out.println(c);
        for(String s : c){
            System.out.println(s);
        }

        c.forEach(s->System.out.println(s));
//        c.forEach(System.out::println);


        Map<String,Integer> map = new HashMap<>();
        map.put("语文",99);
        map.put("数学",98);
        map.put("英语",97);
        map.put("物理",96);
        map.put("化学",99);
        System.out.println(map);
//        map.forEach((k,v)-> System.out.println(k+":"+v));

        //1完整代码
//        BiConsumer<String,Integer> action = new BiConsumer<String, Integer>() {
//            public void accept(String k, Integer v) {
//                System.out.println(k+":"+v);
//            }
//        };
//        Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
//        for(Map.Entry<String,Integer> e : entrySet) {
//            String k = e.getKey();
//            Integer v = e.getValue();
//            action.accept(k,v);
//        }

        //2Map的forEache方法的回调写法
//        BiConsumer<String,Integer> action = new BiConsumer<String, Integer>() {
//            public void accept(String k, Integer v) {
//                System.out.println(k+":"+v);
//            }
//        };
//        map.forEach(action);//这个等效上面41-46行(可参考forEach源代码)

        //3使用lambda表达式形式创建
//        BiConsumer<String,Integer> action =(k,v)->System.out.println(k+":"+v);
//        map.forEach(action);

        //4最终写法
        map.forEach((k,v)->System.out.println(k+":"+v));


    }
}