数组 HashMap Lambda 容器

Day11笔记

一、二维数组

1.理解

二维数组：数组中嵌套数组,数组中还是数组

2.声明和定义

1）声明:

数据类型变量名;

数据类型[] 数组名; —一维数组的声明

数据类型数组名; —二维数组

数据类型[] 数组名[];

数据类型数组名;

2）初始化:

动态初始化: 创建数组对象的时候不赋值,后续赋值

数据类型数组名 = new 数据类型一维的长度;

一维的长度:外层数组

二维的长度:内层的每一个小数组

数据类型数组名 = new 数据类型一维的长度;

数组名[0] = 内层数组的创建方式(不可以使用简略写法);

静态初始化:创建数组对象的同时赋值

数据类型数组名 = new 数据类型{{1,2,3},{2,3},{4}…};

3.数组遍历

数组遍历：循环嵌套

普通for 和增强for

//普通for
        for(int i=0;i<arr.length;i++) {
            for(int j=0;j<arr[i].length;j++) {
                System.out.println(arr[i][j]);
            }   
        }
        System.out.println(Arrays.deepToString(arr));
        //增强for
        for(int[] i:arr) {
            for(int j:i) {
                System.out.println(j);
            }
        }
        System.out.println(Arrays.deepToString(arr));

二、容器

1.理解

容器: 存储多个数据

可以根据数据的个数进行自动变长

存储任意类型的数据,只能为引用数据类型

2.Collection(接口)

list :有序可重复

set :无序不可重复

3.ArrayList

底层实现: 可变数组实现,通过数组的拷贝改变数组的长度动态实现可变

泛型：强制检查容器中所有数据的数据类型 ->引用数据类型

可以提高程序的安全性和可读性

优点: 做查询效率高
缺点: 做增删效率低,通过数组拷贝
应用: 大量做查询,少量做增删的时候推荐使用ArrayList
扩容:每次扩容原容量的1.5倍(newCapacity = oldCapacity + (oldCapacity >> 1);),使用 Arrays.copyOf进行数据的拷贝

遍历:
普通for循环
增强for循环
迭代器

使用List有的列表迭代器

public class ListDemo01 {
    public static void main(String[] args) {
        //接口多态,list引用只能调用List接口中的内容
        List list=new ArrayList();
        List list2=new ArrayList();
        list.add("哈哈");
        list.add(9);
        list.add('a');
        list.add(false);
        list.add(null);
        System.out.println(list);
        
        list2.add("3.3");
        list2.addAll(list);
        System.out.println(list2);
        
        
        List<String> list3=new ArrayList<String>(); //list3容器中所有的数据都要为字符串
        List<String> list4=new ArrayList<String>(); //list3容器中所有的数据都要为字符串
        list3.add("钢铁侠");
        list3.add("时间规划局");
        list3.add("变形金刚");
        list4.addAll(list3);
        //list3.add(false);
        System.out.println(list3);
        //list3.clear();
        System.out.println(list3.size());
        System.out.println(list3.isEmpty());
        
        System.out.println(list3.contains("钢铁侠"));
        list3.remove("钢铁侠");
        System.out.println(list3);
        System.out.println(list4);
        
        list4.retainAll(list3);
        System.out.println(list3);
        System.out.println(list4);
        
        String[] str = list3.toArray(new String[0]);        
        
        System.out.println(Arrays.toString(str));
        //list新增对索引进行操作的系列方法
        list3.add(1, "黑客帝国");
        System.out.println(list3);
        
        list3.set(2, "哈哈哈");
        System.out.println("黑客帝国第一次出现的索引:"+list3.indexOf("黑客帝国"));;
        
        //遍历方式:
        System.out.println("----------for---------------");
        for(int i=0;i<=list3.size()-1;i++){
            System.out.println(list3.get(i));
        }
        
        System.out.println("----------for..each---------------");
        for(String s:list3){
            System.out.println(s);
        }
        System.out.println("----------Iterator迭代器  Collection接口存在---------------");
        //1.获取迭代器对象
        Iterator<String> it=list3.iterator();
        //2.判断是否有下一个元素
        while(it.hasNext()){
            //3.获取下一个元素
            System.out.println(it.next());
        }
        
        System.out.println("---------列表迭代器  list接口新增---------------");
        ListIterator it2=list3.listIterator();
        while(it2.hasNext()){
            System.out.println(it2.next());
        }
        
        //从后往前迭代,通过列表迭代器
    }
}

4.Vector向量

与ArrayList像,都是由数组实现内部存储结构

区别:

早起jdk版本提供,后续jdk版本推荐ArrayList代替Vector

Vector线程安全,效率较低,ArrayList线程不安全,效率较高,重效率轻安全

扩容:每次扩容原容量的2倍,没有ArrayList节省空间

5.LinkedList(链列表)

底层:双向链表实现

优点:增删效率高

缺点:查询效率低

注意:容器中只能存放引用数据类型的数据 int->3

会发生自动拆装箱,不需要我们手动控制

为所有的基本数据类型提供了对应的包装类型

int Integer

byte Byte

short Short

long Long

double Double

float Float

char Character

boolean Boolean

int	Integer
byte	Byte
short	Short
long	Long
double	Double
float	Float
char	Character
boolean	Boolean

6.set集合

Set接口: 无序不可重复
List接口: 有序就可重复

都是Collection的子接口,都是存储单个数据值的容器

无序: 存储的顺序和内部真实存放的顺序不同
实现类: HashSet ..
public class SetDemo01 {
    public static void main(String[] args) {
        Set set=new HashSet();
        set.add("haha");
        set.add("abc");
        set.add("cd");
        set.add("a");
        set.add("hehe");
        set.add("hehe");
        set.add("hehe");
        System.out.println(set);
    }
}

7.Map

Map 容器接口

存储的每一个数据都是k-v组成

k 无序的,不可重复–>Set集合

v 无序的,可重复 –>Collection集合

key和value之间存在映射关系,根据key获取value

一个key,只能对应一个value,如果想要对应多个,可以把value存在容器中

如果存储的数据的时候,key相同的数据value会覆盖

Map的遍历方式:

1.keySet() 获取所有的key,返回一个Set集合,然后可以根据key获取value

2.values() 获取所有的value值,返回一个Collection集合

3.entrySet() 返回此映射中包含的映射关系的Set集合

8.HashMap

底层 : hash表实现(数组+链表+红黑树)

Day12笔记

一、HashMap(数组+链表+红黑树)

1.HashMap表实现

1.存储键值对的数据 key value->在哈希表结构中

2.key获取hashcode()值一个int和整数,根据hash算法进行计算,算出桶的位置

hash算法: hashcode()值 % 数组的长度

hashcode()值 & 数组的长度-1 —->数组的长度必须为2的整数幂

3.先判断对应桶中是否已经存在数据,判断桶中的数据是否与我当前的key相等,使用equals(),如果相等value覆盖,如果不相等,把数据放入链表的最后

对应桶中是否已经存在数据那就直接放入桶中

如果equals相等,hashcode一定要保证相等,保证相等的数据桶的位置一样,才会比较equals进行去重hashcode相等,equals不一定相等,所以我才要放入桶的时候比较equals()

总结: 如果使用hashMap存储数据,key是自定义的引用的数据类型,一定要重写hashcode()和equals()方法

java8:哈希表(数组+链表+红黑树):当桶中的数据超过8个,把结构当前链表结构变为红黑树

初始容量:16

加载因子:0.75 当16*0.75达到临界点12进行扩容

扩容: 扩容位桶的大小

二、Arrays和Collections

1.理解

Arrays(操作数组的工具类)

此类包含用来操作数组（比如排序和搜索）的各种方法

Collections 操作容器的工具类

Collections.方法

方法：翻转—》revers 随机 ——》shuffle

默认升序 —-》sort 填充——-》fill

2.HashMap理解

HashMap 线程不安全,效率较高,可以存储null值

Hashtable 线程安全的哈希表,不能存储null值

如何处理HashMap线程安全问题:

1.可以使用Hashtable

2.在Collections的提高了一个方法synchronizedMap(Map<K,V> m) 返回一个线程安全的map

3.juc包(高级并发编程包)下ConcurrentHashMap,是一个线程安全的HashMap–推荐,效率高

3.内部比较器

内部比较器(自然排序):实现一个Comparable的接口,重写冲向方法compareTo() 在方法内部定义默认比较规则每次修改,都要修改源代码,硬编码。

4.外部比较器

外部比较器(定制排序):实现一个Comparator接口,重写compare(t1,t2) 方法中定义比较规则

5.匿名内部类

存在一个接口,对接口中的抽象方法进行重写,调用方法体实现功能

简化实现类:实现类本身没有自己的作用,只是为了重写抽象方法

6.简化匿名内部类（Lambda）

java8提供了lambda表达式

使用前提:函数式接口

函数式接口: 只有一个必须要重写的抽象方法的接口

检查函数式接口:@FunctionalInterface

语法:

()->{}

() :要重写的抽象方法的参数列表

-> :lambda符号,箭头符号,箭头函数,具有上下文推到作用

{} :定义抽象方法的方法体