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

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

 

 

 

 

 

 

发布了13 篇原创文章 · 获赞 0 · 访问量 69
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 深蓝海洋 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览