Collection集合和Map集合

map.entrySet();

Ctrl+Alt+v自动生成

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

目录

ArrayList常见的方法

集合框架：

Collection: 

Collection常见方法：

Collection的遍历方式： 

ArrayList集合的底层原理：

LinkedList集合的底层原理：

---

ArryList//集合大小可变，开发中用的更多。相对于数组其规定长度后无法改变。

ArrayList常见的方法

ArrayList<>//<>中没有标明限制对象则称为泛型。

注意：1.集合和泛型都不支持基本数据类型，只能支持引用数据类型。（int.long.shout......不支持）String支持。int在<>中为integer;

2.集合容器中存储的是每个对象在堆内存中的地址！

package com.itheima.arraylist;

import java.util.ArrayList;

public class ArrayListDemo1 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<String>();//无参数构造器
        //1.将元素添加到集合的末尾。
        list.add("黑马");
        list.add("java");
        list.add("黑马");
        list.add("heima");
        System.out.println(list);//最初打印的是list的地址，然后在根据地址找到list的内容。
        //2.在集合的指定位置添加指定元素。
        list.add(1,"HySQL");
        System.out.println(list);
        //3.返回指定索引处的元素位置。
        System.out.println(list.get(1));
        //获取集合中的元素个数
        System.out.println(list.size());
        //5.根据索引删除元素中得值
        System.out.println(list.remove(1));
        System.out.println(list);
        //6.直接删除某个元素值。删除成功返回true.反之返回false
        System.out.println(list.remove("java"));
        System.out.println(list);//若元素中有两个黑马元素那么只删除第一个黑马元素。！！！
        //7.修改数据
        System.out.println(list.set(1, "JAVA"));//得到的是要替换的元素
        System.out.println(list);


    }
}

ArrayList的应有案例 ：

package com.itheima.arraylist;

import java.lang.reflect.Array;
import java.util.ArrayList;

public class ArrayListDemo2 {
    public static void main(String[] args) {
        ArrayList<String>list=new ArrayList<>();
        list.add("java入门");
        list.add("宁夏枸杞");
        list.add("黑枸杞");
        list.add("人字拖");
        list.add("特级枸杞");
        list.add("枸杞子");
        System.out.println(list);
        //在集合中找到含”枸杞“的数据并删除他。
//        for (int i = 0; i < list.size() ; i++) {
//            String ele= list.get(i);
//            if(ele.contains("枸杞")){
//                list.remove(ele);
//                --i;
//            }
//        }
//        System.out.println(list);//从前面往后面遍历每删除一个后面的元素会自动补充该位置导致其”黑枸杞“不能被删除。
        for (int i = list.size()-1; i >=0 ; i--) {//从后往前面遍历
            String ele= list.get(i);
            if(ele.contains("枸杞")){
                list.remove(ele);
            }
        }
        System.out.println(list);
    }
}

ArrayListDemo1,Food,FoodOperator .java中有面向对象模拟实际餐厅吃饭场景。

常用API(String,ArrayList)应用程序编程接口，Java写好的程序，给程序员来调用。

集合框架：

Collection单列集合，Map双列集合

Collection: 

List<E>系列集合：添加的元素是有序，可重复，有索引。

ArrayList.LinekList

Set<E>系列集合：添加的元素是无序，不重复，无索引。

HashSet：无序，不重复，无索引。

LinkedHashSet:有序，不重复，无索引

TreeSet：按照大小默认升序排列，不重复，无索引。

Collection常见方法：

Collection<String>c=new ArrayList<>();
        //添加元素，添加成功返回true   //public boolean add(E e);
        c.add("java1");
        c.add("java1");
        c.add("java2");
        c.add("java2");
        c.add("java3");
        System.out.println(c);
        //清空集合中的元素
//        c.clear();
//        System.out.println(c);
        //判断集合是否为空，时空的话返回true
        System.out.println(c.isEmpty());
        //获取集合的大小
        System.out.println(c.size());
        //判断集合中是否包含某个元素
        System.out.println(c.contains("java2"));
        //删除某个元素默认是删除第一个
        System.out.println(c.remove("java1"));
        //将集合转化为数组
        Object[] arr = c.toArray();
        System.out.println(Arrays.toString(arr));
        String[]arr2=c.toArray(new String[0]);
        System.out.println(Arrays.toString(arr2));
        System.out.println("--------------------");
        Collection<String>c1=new ArrayList<>();
        c1.add("java1");
        c1.add("java2");
        Collection<String>c2=new ArrayList<>();
        c2.add("java3");
        c2.add("java4");
        c1.addAll(c2);
        System.out.println(c1);
        System.out.println(c2);

Collection的遍历方式： 

 //创建一个迭代器对象
 Iterator<String> it = c.iterator();
while(it.hasNext()){
    String ele=it.next();
    System.out.println(ele);
}
//增强for循环来遍历
 for (String s : c) {
     System.out.println(s);

 }
 System.out.println("-----------");
 //使用Lambda表达式来遍历集合
 c.forEach(new Consumer<String>() {
     @Override
     public void accept(String s) {
         System.out.println(s);
     }
 });
 c.forEach((String s)->{
     System.out.println(s);
 });
 c.forEach(s->{
     System.out.println(s);
 });
 c.forEach(s-> System.out.println(s) );
 c.forEach(System.out::println );

ArrayList集合的底层原理：

基于数组实现的

 特点：查询速度快

           删除速率低：可能需要把后面很多的数据进行前移

           添加效率极低：可能要把后面的很多数据后移；或者也需要进行数组的扩容

原理：一：利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组；

二：添加第一个元素时，底层会创建一个新的长度为10的数组；

三：存满时，会扩容1.5倍。//15个格子

四：如果一次添加多个元素，1.5倍还放不下，则新创建的长度以实际为准。

LinkedList集合的底层原理：

基于双链表实现的。

特点：查询慢，增删相对较快，但对首位元素进行增删改查的速度是极快的。

push=addFirst

pop=addLast//方法结果相同

应用场景之一是：可以用来设计队列。

可以用来设计栈。

Set系列集合：

HashSet<E>

TreeSet<E>

LinkedHashSet<E>//是HashSet的子类

哈希值：

就是一个int类型的数值，Java中的每一个对象都有一个哈希值。

Java中的所有对象，都可以调用Object类提供的hashCode方法，返回该对象自己的哈希值。

特点：同一个对象多次调用hashCode（）方法返回的哈希值是相同的。

不同对象，他们的哈希值一般是不相同的。但也有可能会相同（哈希碰撞）。

HashSet集合中相同内容的不同对象不认为是重复的。

HashSet集合去重复详解：必须重写对象hashCode（）和equals（）方法。

TreeSet：

升序，不重复，无索引。

当是指定义类（如学生）则无法进行升序排序；

解决方法：1.学生类实现Compareable类接口，重写Compareable方法。

2.重写Comparetor对象。

//注意：TreeSet集合元素的比较采用就近原则，调用就近的构造器进行比较。

集合的并发修改异常：

使用迭代器遍历集合时，有同时再删除集合中的数据，程序就会出现并发修改异常的错误。

可变参数：

就是一种形参，定义在方法，构造器的形参列表里，格式是：数据类型。。参数名称。

特点：可以不穿数据给他，可以穿一个或者同时传多个数据给他，也可以穿一个数组给他；

好处：常常用来灵活地接受数据，                                                                                                     

 //test();
    test(12);
    test(12,35,45);
   // test(new int[]{11,23,21,13,24});

}
//注意：一个形参列表中，只能有一个可变参数
//注意二：可变参数必须放在形参列表的最后面。
public static void test(int age,int...nums){
    System.out.println(nums.length);
    System.out.println(Arrays.toString(nums));
    System.out.println("------");

Map集合 ：

常见方法：

存储一一对应的数据

HashMap无序，不重复，无索引；

LinkedHashMap有序，不重复，无索引；

TreeMap按照大小默认升序排列，不重复，无索引；（由键决定）                                                 

 Map<String,Integer>map=new LinkedHashMap<>();//无序，不重复，无索引。HashMap
 map.put("手表",100);
 map.put("手表",220);
 map.put("手机",2);
 map.put("Java",2);
 map.put("null",null);
 System.out.println(map);
 Map<Integer,String>map1=new TreeMap<>();//升序
 map1.put(23,"Java");
 map1.put(23,"MySQL");
 map1.put(19,"李四");
 map1.put(28,"王五");
 System.out.println(map1);
 //Map集合地一些方法
 //获取集合的大小
 System.out.println(map.size());
 //清空集合
// map.clear();
 //System.out.println(map);
 //判断集合是否为空
 System.out.println(map.isEmpty());
 //根据键获取相应的值
 System.out.println(map.get("Java"));//得到的是Java键对应的值
 System.out.println(map.get("手机"));
 //根据键清除某个元素,返回的是键的值。
 System.out.println(map.remove("null"));
 //判断是否包含某个值，如果有返回true
 System.out.println(map.containsKey("手表"));
 //判断是否含有某个值
 System.out.println(map.containsValue(220));
 //获取集合的全部键
 Set<String>keys=map.keySet();
 System.out.println(keys);
 //获取全部的值
 Collection<Integer>values=map.values();
 System.out.println(values);
 //map方法中的putAll

  Map集合的遍历方式 ：                                                                       

1.键找值

2.键值对

3.Lambda表达式                                                                                                                                   

Map<String,Double>map=new HashMap<>();
map.put("蜘蛛精",162.5);
map.put("蜘蛛精",169.8);
map.put("紫霞",165.8);
map.put("至尊宝",169.5);
map.put("牛魔王",183.6);
System.out.println(map);
//键找值
//得到所有的键
Set<String> keys = map.keySet();
System.out.println(keys);
for (String key : keys) {
    Double value=map.get(key);
    System.out.println(key+"=====>"+value);
}
System.out.println("------------------");
//键值对
Set<Map.Entry<String, Double>> entries = map.entrySet();
for (Map.Entry<String, Double> entry : entries) {
    String key=entry.getKey();
    Double value=entry.getValue();
    System.out.println(key+"=====>"+value);
}
System.out.println("------------------");
//Lambda方法遍历
map.forEach((k,v)->{
    System.out.println(k+"=====>"+v);
});