数组 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

 

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符号,箭头符号,箭头函数,具有上下文推到作用

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