二维数组与容器

一、二维数组

数组中嵌套数组(数组中还有数组)

1、声明

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

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

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

int[][] arr6;
int[] arr4[];
int arr5[][];

2、初始化

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

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

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

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

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

//      动态初始化
        int[][] arr1=new int[3][4];
        int[][] arr2=new int[3][];
//      静态初始化
        int[][] arr3={{1,2,3},{4,5,6,7},{8,9}};
        int[][] arr=new int[][] {{1,2,3},{4,5,6,7},{8,9}};

3、二维数组遍历

嵌套循环:

  1. 增强for:遍历数组中的每一个数据值

  2. 普通for:遍历数组的索引(下标)

        int[][] arr=new int[][] {{1,2,3},{4,5,6,7},{8,9}};
        System.out.println(Arrays.deepToString(arr3));//把数组中的内容深层以字符串的形式返回,多维度需要
        System.out.println(Arrays.deepEquals(arr3, arr));//深层比较内容,多维度需要
        //增强for
//      for(int[] a:arr) {
//          for(int b:a) {
//              System.out.println(b);
//          }
//      }
        //普通for
        for(int i=0;i<arr.length;i++) {
            for(int j=0;j<arr[i].length;j++) {
                System.out.println(arr[i][j]);
            }
        }

二、容器

1、特点

  • 可以存储多个数据

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

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

数组特点:有序、数据类型相同、定长;

作用:存储多个数据

注意:容器中只能存放引用数据类型的数据,会自动拆装箱,不需要手动控制,为所有的基本数据类型提供了对应的包装类型

2、ArrayList

Collection:接口 容器类的父接口:

  • list子接口:有序可重复

  • set子接口:无序不可重复

泛型:<类型>强制检查容器中所有数据的数据类型

ArrayList():内部空数组;

ArrayList(int initialCapacity):创建指定大小的容器,当能够确定数据多少时使用,效率更高;

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

优点:做查询时效率高,(线程不安全,效率高

缺点:做增删效率低,通过数组拷贝(数组为定长)

扩容:每次扩容原容量的1.5倍(newCapacity = oldCapacity + (oldCapacity >> 1);)

应用:做大量查询,少量做增减时推荐使用

遍历

  • 普通for

  • 增强for

  • 迭代器

  • 使用list有的迭代器

public class ListTest {
    public static void main(String[] args) {
        //接口多态
        List ls1=new ArrayList();
        List ls2=new ArrayList();
        //添加
        ls1.add(1);
        ls1.add("xiaoming");
        ls1.add(true);
        ls1.add(3.4);
        ls1.add('a');
        //添加指定位置
        ls1.add(1, 2);
        System.out.println(ls1);
        //添加list
        ls2.addAll(ls1);
        System.out.println(ls2);
        //泛型<类型>:强制检查容器中所有数据的数据类型
        List<String> ls3=new ArrayList();
        List<String> ls4=new ArrayList();
//      ls3.add(123);//报错,只能添加字符串类型
        ls3.add("小米");
        ls3.add("小小");
        ls3.add("小楠");
        System.out.println(ls3);
        ls4.addAll(ls3);
        System.out.println(ls4);
        System.out.println(ls3.contains("小小"));//判断是否存在小小
        System.out.println(ls3.isEmpty());//判断是否为空
        System.out.println(ls3.size());//list中的长度
        ls3.remove(2);//移除下标为2的
        System.out.println(ls3);
        System.out.println(ls3.indexOf("小小"));//值为小小时第一次出现的索引
        //普通for
        for(int i=0;i<ls3.size();i++) {
            System.out.println(ls3.get(i));
        }
        //增强for
        for(String i:ls3) {
            System.out.println(i);
        }
        //迭代器
        Iterator<String> iterator = ls3.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("==================");
        //列表迭代器
        ListIterator<String> listIterator = ls3.listIterator();
        while(listIterator.hasNext()) {
            System.out.println(listIterator.next());
        }
    }
}

3、Vector(向量)

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

区别:早期jdk版本提供,后期jdk版本推荐使用ArrayList取代了Vector

ArrayList:线程不安全,效率高,重效率轻安全

Vector:线程安全,效率低,

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

        //Vector
        Vector vc=new Vector();

4、LinkbedList

底层:双向链表实现

优点:增删效率高

缺点:查询效率低

        //链表LinkedList
        LinkedList<String> linkedList = new LinkedList();

5、常用方法

  • add():增加

  • get():获取

  • remove():删除

  • set():修改

        //定义一个list
        ArrayList arr=new ArrayList();
        //添加
        arr.add("小娜");
        arr.add("小楠");
        arr.add("小小");
        System.out.println(arr);
        //修改
        arr.set(1, "xiaonan");
        System.out.println(arr);
        //查询
        System.out.println(arr.get(2));
        //删除
        arr.remove(0);
        System.out.println(arr);
        //添加值在指定位置
        arr.add(1, "小米");
        System.out.println(arr);

6、Map

1.特点

map容器接口:存储的每一个数据都是k-v组成

k——无序的,不可重复(set集合)

v——无序的,可重复(Collection集合)

key和value之间存在映射关系,根据key获取value,一个key,只能对应一个value,如果想要对应多个,可以把value存在容器中;

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

2.map的遍历方式:

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

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

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

3.常用方法:

  • put():添加

  • get():获取

  • containsKey():判断key是否存在

  • containsValue():判断value是否存在

  • remove():移除

public class MapTest {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap();
        //添加
        map.put(1, "xiaoxiao");
        map.put(2, "xiaoming");
        map.put(3, "小夏");
        map.put(4, "小楠");
        System.out.println(map);
        //根据key获取值
        System.out.println(map.get(2));
        //判断key是否在map中
        System.out.println(map.containsKey(3));
        //判断value是否在map中
        System.out.println(map.containsValue("xiaoxiao"));
        //移除
        System.out.println(map.remove(1));//输出移除的数据
        System.out.println(map);
        //遍历
        System.out.println("---------keySet()---------");
        Set<Integer> set = map.keySet();//获取数组
        System.out.println(set);
        for(Integer i:set) {
            System.out.println(map.get(i));
        }
        System.out.println("---------values()----------");
        Collection<String> collection = map.values();
        System.out.println(collection);
        //增强for
        for(String i:collection) {
            System.out.println(i);
        }
        //迭代器
        Iterator<String> iterator = collection.iterator();
        while(iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("---------entrySet()----------");
        Set<Entry<Integer,String>> entrySet = map.entrySet();
        System.out.println(entrySet);
        //迭代器
        Iterator<Entry<Integer, String>> iterator2 = entrySet.iterator();
        while(iterator2.hasNext()) {
            System.out.println(iterator2.next());
        }
        
    }
}

7、HashMap

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

hashCode():获取哈希码值;

        StudentInfo stu2=new StudentInfo("小夏","207",18);
        StudentInfo stu3=new StudentInfo("小名","207",17);
        System.out.println(stu2.hashCode());
        System.out.println(stu3.hashCode());
        System.out.println("haihai".hashCode());
        Integer i=12;//为引用类型
        System.out.println(i.hashCode());
发布了7 篇原创文章 · 获赞 3 · 访问量 199
展开阅读全文

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

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

分享到微信朋友圈

×

扫一扫,手机浏览