集合

         

collection集合的常用功能

Collection<String> coll = new ArrayList<>();
System.out.println(coll);
//添加数据，成功返回true，否则返回false
coll.add("赵四");
coll.add("刘恩");
coll.add("成龙");
System.out.println(coll);
//删除数据，成功返回true，否则返回false
coll.remove("赵四");
System.out.println(coll);
//判断是否包含，包含返回true,否则返回false
coll.contains("成龙");
//判断当前集合是否为空，集合为空返回true，集合不为空返回false
coll.isEmpty();
//返回集合中的元素个数
System.out.println(coll.size());
//把集合中的元素存储到数组中
Object[] arr = coll.toArray();
/*
for (Object o : arr) {
     System.out.println(o);
}*/
for (int i=0;i<arr.length;i++){
      System.out.println(arr[i]);
}
//清空集合
coll.clear();
System.out.println(coll);

迭代器的实现

　　　　　//创建集合对象
        Collection<String> coll = new ArrayList<>();
        //往集合中添加元素
        coll.add("姚明");
        coll.add("科比");
        coll.add("麦迪");
        coll.add("詹姆斯");


        Iterator<String> it = coll.iterator();
        //使用iterator接口中的方法hasnext判断还有没有下一个元素
        //方法一
        while (it.hasNext()){
            String next = it.next();
            System.out.println(next);
        }
        /*
        //方法二
        for (Iterator<String> it2 = coll.iterator();it2.hasNext();){
            String next = it2.next();
            System.out.println(next);
        }

        //方法三
        boolean b = it.hasNext();
        System.out.println(b);
        String next = it.next();
        System.out.println(next);

        b = it.hasNext();
        System.out.println(b);
        next = it.next();
        System.out.println(next);

        b = it.hasNext();
        System.out.println(b);
        next = it.next();
        System.out.println(next);

        b = it.hasNext();
        System.out.println(b);
        next = it.next();
        System.out.println(next);

        b = it.hasNext(); //没有下一个值返回false
        System.out.println(b);
        next = it.next();  //取不到下一个值会报错
        System.out.println(next);
*/

增强for循环

/*格式for(集合/数组的数据类型 变量名:集合名/数组名字){
        sout(变量名)
    }
    */

    //使用增强for循环遍历集合
    ArrayList<String> list = new ArrayList<>();
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add("ddd");
    for (String s:list){
        System.out.println(s);
    }
    //使用增强for循环遍历数组
    int[] arr = {1,2,3,4,5};
    for (int i : arr) {
        System.out.println(i);
    }
}

 泛型的概念：是一种未知的数据类型，当我们不知道用什么数据类型的时候，可以使用泛型，泛型

 　　　　　　可以看成是一个变量，用来接收数据类型；创建集合的时候，就确定了数据类型。

创建集合使用泛型：

　　　　　　　　　　优势：1.避免类型转换的麻烦，存储是什么类型，取出是什么类型

　　　　　　　　　　　　　2.把运行期异常（运行之后报错），提升到编译器（写代码报错）

　　　　　　　　　　弊端:1.泛型是什么类型，只能存储什么类型的数据

创建集合不使用泛型：

　　　　　　　　　　优势：集合不使用泛型，默认就是object类型，可以存储任意类型的数据

　　　　　　　　　　弊端：不安全，会引发异常

定义和使用泛型的类：

定义和使用泛型的方法：

定义和使用泛型的接口：

泛型的通配符？

数据结构

　　　　栈：先进后出

　　　　队列：先进先出

　　　　链表：查询慢：每次查询元素，都必须从头开始查询

　　　　　　　增删快：链表结构，增加和删除元素，对链表的整体结构没有影响，所以增删快

　　　　　　　单向链表：链表中只有一条链子，不能保证元素的顺序(存储元素和取出元素的顺序有可能不一样)

　　　　　　　双向链表：链表中有两个链子，有一条链子是专门记录元素的顺序，是一个有序的集合

 　　　　红黑树：查询速度非常快

list集合特点

　　　　　　1.有序集合，存储元素和取出元素的顺序是一致的

　　　　　　2.有索引，包含了一些带索引的方法

　　　　　　3.允许存储重复元素

//创建一个list集合多态
List<String> list = new ArrayList<>();
//使用add方法添加元素
list.add("b");
list.add("c");
list.add("d");
list.add("a");
//打印集合
System.out.println(list);
//指定索引处添加元素
list.add(2,"你好");
System.out.println(list);
//移除指定索引元素，返回被移除的元素
String remove = list.remove(2);
System.out.println(remove);
System.out.println(list);
//用指定元素替换集合中的指定元素，返回值的更新前的元素
String a = list.set(3, "A");
System.out.println(a);
System.out.println(list);
//普通for循环遍历
for (int i = 0;i<list.size();i++){
    String s = list.get(i);
    System.out.println(s);
}
System.out.println("-------------------");
//使用迭代器
Iterator<String> it = list.iterator();
while (it.hasNext()){
    String next = it.next();
    System.out.println(next);
}
System.out.println("-------------------");
//增强for
for (String s : list) {
    System.out.println(s);
}

list集合(可以存储重复元素)

ArrayList集合 ：查询快，增删慢

LinkedList集合：查询慢，增删快

//创建对象
LinkedList<String> linked = new LinkedList<>();
//使用add方法往集合中添加元素,add等效于addlast
linked.add("a");
linked.add("b");
linked.add("c");
System.out.println(linked);
//将指定元素插入列表的头,addfirst等效于push
linked.addFirst("e");
//linked.push("e");
System.out.println(linked);
//获取集合第一个元素
String first = linked.getFirst();
System.out.println(first);
//获取几何中最后ige元素
String last = linked.getLast();
System.out.println(last);
//移除并返回列表的第一个元素
linked.removeFirst();
//移除并返回列表的最后一个元素
linked.removeLast();
//移除并返回第一个元素
linked.pop();
//判断集合是否为空
linked.isEmpty();
//清空集合元素
linked.clear();

set集合(1.不允许重复元素2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历)

HashSet集合

1.不允许重复元素

2.没有索引，没有带索引的方法，也不能使用普通的for循环遍历

3.是一个无序的集合，存储和取出元素的顺序有可能不一致

4.底层是一个哈希结构（查询速度非常的快）

//创建对象
HashSet<Integer> set = new HashSet<>();
//添加元素
set.add(2);
set.add(4);
set.add(3);
set.add(4);
//使用迭代器遍历
System.out.println(set);
Iterator<Integer> it = set.iterator();
while (it.hasNext()){
    Integer next = it.next();
    System.out.println(next);
}

//增强for遍历
for (Integer integer : set) {
    System.out.println(integer);
}

collections集合工具类的方法

//创建对象
ArrayList<String> list = new ArrayList<>();
//往集合中添加一些元素
Collections.addAll(list,"a","b","c","d","e");
System.out.println(list);
//打乱集合顺序
Collections.shuffle(list);
System.out.println(list);
Collections.sort(list);
System.out.println(list);

排序规则

        //创建对象
        ArrayList<Integer> list = new ArrayList<>();
        //往集合中添加一些元素
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list);
        Collections.sort(list, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
　　　　　　　　　 //return o1-o2;//升序
                return o2-o1;//降序
            }
        });
        System.out.println(list);

map集合

1.是一个双列集合，一个元素包含两个值（一个key，一个value）

2.集合中的元素，key和value的数据类型可以相同，也可以不同

3.key不允许重复,value可以重复

4.key和value是一个对应一个的

HashMap<String, String> map = new HashMap<>();
//没有重复返回null
String v1 = map.put("李晨", "范冰冰");
System.out.println(v1);

//返回被替换的值
String v2 = map.put("李晨", "范冰冰2");
System.out.println(v2);

map.put("冷锋","龙小云");
map.put("杨过","小龙女");
map.put("尹志平","小龙女");
System.out.println(map);
//key存在返回被删除的值，key不存在返回空
map.remove("冷锋");
System.out.println(map);
//根据key获取value
String v3 = map.get("杨过");
System.out.println(v3);
//判断是否含有指定的键，有返回true，没有返回false
boolean v4 = map.containsKey("杨过");
System.out.println(v4);

map集合遍历键找值的方式

//创建对象
Map<String, String> map = new HashMap<>();
map.put("冷锋","龙小云");
map.put("杨过","小龙女");
map.put("尹志平","小龙女");

//使用map集合中的方法keyset，把map集合所有的key取出来，存到set集合中
Set<String> set = map.keySet();
//遍历set集合
Iterator<String> it = set.iterator();
while (it.hasNext()){
    String next = it.next();
    System.out.println(map.get(next));
}

//使用增强for
for (String key : set) {
    System.out.println(map.get(key));
}

entry键值对对象

//创建对象
Map<String, String> map = new HashMap<>();
map.put("冷锋","龙小云");
map.put("杨过","小龙女");
map.put("尹志平","小龙女");

Set<Map.Entry<String, String>> set = map.entrySet();

//迭代器遍历
Iterator<Map.Entry<String, String>> it = set.iterator();
while (it.hasNext()){
    Map.Entry<String, String> next = it.next();
    String key = next.getKey();
    String value = next.getValue();
    System.out.println(key + value);
}

//增强for遍历
for (Map.Entry<String, String> entry : set) {
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key + value);
}