arrays中copyof复制两个数组_二维数组/容器

1.二维数组

顾名思义就是在数组中存在数组

声明

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

初始化:

​ 动态初始化:

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

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

arr[0] = new int[3];
arr[0] = new int[]{1,2,3};

​ 静态初始化:

​ 数据类型[][] 数组名 = new 数据类型[][]{{'a','b'},{'c','d','e'},{'f'}};

​ 数据类型[][] 数组名 = {{'a','b'},{'c','d','e'},{'f'}};

根据索引操作数组:arr[索引]

可以简单的将前面[]中认为行数
后面[]认为列数
第3行第3列表示: 数组[2] [2];

public class ArrayDemo01 {
    public static void main(String[] args) {
        //二维数组动态初始化
        //最原始方法一个一个赋值
        //索引注意从0开始,到length-1结束
        //比如第一行第二个数就为   数组[0][1];
        int[][] arr1=new int[2][3];
        arr1[0][0] = 1;
        arr1[0][1] = 2;
        arr1[0][2] = 3;
        arr1[1][0] = 4;
        arr1[1][1] = 5;
        arr1[1][2] = 6;
        System.out.println(Arrays.deepToString(arr1));
        //给定长度(行数),列不确定,自定义
        double[][] arr2=new double[2][];
        arr2[0] = new double[3];
        arr2[1] = new double[]{4,5};
        arr2[0][0] = 1;
        arr2[0][1] = 2;
        arr2[0][2] = 3;
        System.out.println(Arrays.deepToString(arr2));

        //静态初始化(定义就赋值)
        char[][] arr3 = new char[][]{{'a','b'},{'c','d','e'},{'f'}};
        System.out.println(Arrays.deepToString(arr3));

        String[][] arr4= {{"你好","李焕英"},{"哈哈哈"}};
        System.out.println(Arrays.deepToString(arr4));

        //遍历
        //for..each嵌套for..each
        for(char[] ch:arr3){
            for(char c:ch){
                System.out.println(c);
            }
        }

        //普通for嵌套增强for
        for(int i=0;i<=arr4.length-1;i++){
            for(String s:arr4[i]){
                System.out.println(s);
            }
        }
    }
}

数组遍历除了for循环增强循环还可以用

Arrays 操作数组工具类,静态工厂
下面讲一下它所常用的方法

import java.util.Arrays;
public class ArraysDemo02 {
    public static void main(String[] args) {
        char[][] arr = new char[][]{{'b','a'},{'c','f','e'},{'f'}};
        //deepToString()多维数组以字符串的形式打印内容**
        //ToString() 一维数组以字符串的形式打印内容
        //deepEquals()多维数组比较*内容*是否相等
        //equals() 一维数组比较*内容*是否相等
        System.out.println(Arrays.deepToString(arr));

        int[] arr2=new int[]{3,2,1,4,5,9,7,8,6};
        //fill(数组,数据值) 填充
        //Arrays.fill(arr2, 5);//填充所有
        //打印[5, 5, 5, 5, 5, 5, 5, 5, 5]
        System.out.println(Arrays.toString(arr2));
        //fill(数组,起始索引,结束索引,数据值)  结束索引不包含
        //Arrays.fill(arr2,3,5, 0);
        //[3, 2, 1, 0, 0, 9, 7, 8, 6]注意不包含索引结束

        //sort() 排序 默认升序,对字符|字符串,根据Unicode表中字符代表的值进行排序
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));
        //[1, 2, 3, 4, 5, 6, 7, 8, 9]
        char[] arr3 = new char[]{'b','a','f','e','c'};
        Arrays.sort(arr3);
        System.out.println(Arrays.toString(arr3));
        //[a, b, c, e, f]

        //static char[] copyOf(char[] original, int newLength)  拷贝,截取,填充
        System.out.println(Arrays.toString(Arrays.copyOf(arr3, 3))); 
        //[a, b, c]
        System.out.println(Arrays.toString(Arrays.copyOf(arr3, 5))); 
        //[a, b, c, e, f]
        System.out.println(Arrays.toString(Arrays.copyOf(arr3, 10))); 
        //[a, b, c, e, f, 口,口,口,口,口]//不够就补齐
        //static char[] copyOfRange(char[] original, int from, int to)  结束索引不包含  将指定数组的指定范围复制到一个新数组。 
        System.out.println(Arrays.toString(Arrays.copyOfRange(arr3, 1,3))); 
        //[b, c]注意不包括末尾索引

        /*
         * 先升序排序
         * static int binarySearch(char[] a, char key) 
            使用二分搜索法来搜索指定的 char 型数组，以获得指定的值。 
           static int binarySearch(char[] a, int fromIndex, int toIndex, char key) 
                  使用二分搜索法来搜索指定的 char 型数组的范围，以获得指定的值。 
            如果数据不存在,返回 -插入点-1
         */
        System.out.println(Arrays.binarySearch(arr2, 5));
    }
}

容器

容器: 存储多个数据 * 变量:存储单个数据

• 数组:存储多个数据
• 特点:

1.定长

2.数据类型相同

3.有序(索引)

• 容器:

1.可以存储不同类型的数据,之能存储引用数据类型的数据

2.长度可以随着数据的多少而进行改变

• 自定义容器类:
• MyContainer 只能存储字符串数据 ,内部使用数组存储,查询效率高,增删效率低

//先写个自定义容器类
public class App01 {
    public static void main(String[] args) {
        //县创建容器
        MyContainer my=new MyContainer();
        //存储数据   对象.add();
        my.add("钢铁侠");
        my.add("蜘蛛侠");
        my.add("奇异博士");
        System.out.println(my.size());//对象.size();长度
        System.out.println(my);
        //获取     对象.get();
        System.out.println(my.get(0));
        System.out.println(my.get(1));
        System.out.println(my.get(2));
    }
}
//自定义容器类
class MyContainer{
    private String[] arr;  //真实内部存储数据的结构
    private int size; //容器中存储数据的个数

    public MyContainer() {
        arr=new String[0];
    }

    //根据索引获取内容 
    public String get(int index) {
        if(index<0 || index>=size){//判断索引
            throw new ArrayIndexOutOfBoundsException();
        }
        return arr[index];
    }

Collection 容器的顶层接口

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
/*
 * 集合|容器:
 *  1.可以存储不同类型的数据,之能存储引用数据类型的数据
 *  2.长度可以随着数据的多少而进行改变
 */
public class CollectionDemo02 {
    public static void main(String[] args) {
        Collection col=new ArrayList();//
        col.add(1);
        col.add("哈哈");
        col.add(false);
        col.add('2');
        col.add(3.3);
        System.out.println(col);
        //[1, 哈哈, false, 2, 3.3]
        //泛型 提高可读性,规范数据的类型
        //可以在父类后<>中填上数据类型，注意基本数据类型不可，需要用引用类型
        Collection<String> col2=new ArrayList();
        col2.add("hehe");
        col2.add("haha");
        col2.add("xixi");
        System.out.println(col2);
        //[hehe, haha, xixi]
        Collection<Integer> col3=new ArrayList();
        col3.add(1);
        col3.add(2);
        col3.add(3);
        System.out.println(col3);
        //[1, 2, 3]
        //删除 remove()
        col2.remove("haha");
        System.out.println(col2);
        //[hehe, xixi]
        // boolean contains(Object o) //是否包含 o
        System.out.println(col.contains("哈哈")); 
        //   true
        //不能直接把Object[]数组转为其他类型的数组,可以取其中数据
        //也适用于to.Array();
        Object[] arr=col2.toArray();
        System.out.println(Arrays.toString(arr));
        //[hehe, xixi]
        //遍历:
        //for..each
        for(String o:col2){
            System.out.println(o);
        }
        //迭代器
        //1.获取迭代器对象
        Iterator it=col2.iterator();
        //2.判断是否有下一个元素it.hasNext()
        while(it.hasNext()){
            //3.获取下一个元素it.next()
            System.out.println(it.next());
        }
    }
}

List接口的实现类:

/* * List接口的实现类: * 有序,可重复 * ArrayList: * 数据结构: 可变数组实现的 * 特点:根据索引进行查询,遍历效率高,增删效率低,涉及到数据的拷贝问题 * 扩容机制:使用copyOf方法进行动态扩容,为原容量的1.5倍 * 新增方法:无新增方法 * Vector: * 与ArrayList非常像,区别: 1)线程安全的,效率较低 2)每次扩容是原容量的2倍 * LinkedList: * 数据结构: 双向链表实现 * 特点:做增删效率高,遍历|根据索引查询效率低 * 新增方法:新增了一些操作与链表头尾的方法 * 去创建list的实现类对象,简单操作练习 * 定义ArrayList,存储Person类型的数据,判断new Person("张三",18)在容器中第一次出现的索引 */

import java.util.ArrayList;
public class ArrayListDemo03 {
    public static void main(String[] args) {
        ArrayList<Person> p=new ArrayList();
        p.add(new Person("杜紫藤",18));
        p.add(new Person("支付宝",19));
        p.add(new Person("史珍享",20));

        System.out.println(p);
        System.out.println(p.indexOf(new Person("支付宝",19)));


    }
}
//创建  人   类
public class Person {
    private String name;
    private int age;
    //空构造 快捷键 Alt+/
    public Person() {
        // TODO Auto-generated constructor stub
    }
//带参 快捷键 Alt+shift+s----r
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
//setget快捷键  Alt+shift+s----o
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    //重写equals方法,比较对象时比较对象的内容,非地址
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }



}

List接口特点: 有序(索引),可重复
​ 新增方法:可以根据索引操作的方法
遍历:
* 增强for
* 普通for
* 迭代器 iterator

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo01 {
     public static void main(String[] args) {
        List<Integer> ls=new ArrayList<Integer>();//int型
        ls.add(5);
        ls.add(4);
        ls.add(3);
        ls.add(2);
        ls.add(6);
        System.out.println(ls);//[5, 4, 3, 2, 6]
        //ls.add(0, 6); 根据索引添加元素
        ls.add(0, 1);
        System.out.println(ls);//[1, 5, 4, 3, 2, 6]在该位置添加不覆盖
        //get(index) 获取
        System.out.println(ls.get(3));//3
        //remove(index) 如果索引与内容存在相同情况,以索引为主
        System.out.println(ls.remove(1));//5
        System.out.println(ls);//[1, 4, 3, 2, 6]
        // E set(int index, E element) 修改数据
        System.out.println(ls.set(1, 40));//4修改的数据为索引【1】中的4
        System.out.println(ls);//[1, 40, 3, 2, 6]

        System.out.println("-------for--------");
        for(int i=0;i<ls.size();i++){
            System.out.println(ls.get(i));
        }

        System.out.println("-------for..each()--------");
        for(Integer in:ls){
            System.out.println(in);
        }
        System.out.println("-------iterator()--------");
        //1)获取迭代器对象
        Iterator it=ls.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

HashSet :

/* * Set 无序,不可重复的,会实现去重效果 * 无序:存放的顺序和内容真实存储的顺序不一致 * 遍历: * 1.for..each * 2.迭代器 */

import java.util.HashSet;
import java.util.Set;
public class SetDemo01 {
    public static void main(String[] args) {
        //去重对于java提供类型的数据实现了自动去重,但是如果是我们自定义的类型,去重问题需要关注
        Set set=new HashSet();
        set.add('d');
        set.add('a');
        set.add('c');
        set.add('e');
        set.add('b');
        set.add('b');
        set.add('b');
        set.add('b');
        System.out.println(set);//[a, b, c, d, e]
    }
}

```java / * HashSet : * 底层结构: 哈希表实现(数组+链表+红黑树) * 特点: 查询效率高,增删效率高,但是无序 * 底层是由HashMap维护的,就是HashMap中的key
* 构造器中使用最多的:
* HashSet() 默认初始16个大小,加载因子0.75
* HashSet( int initialCapacity) 指定容量的容器,当能够确定存储数据的个数,就是用这个构造器
* * 测试:存储自定义的Person数据,如何实现去重问题,我们认为Person类所有成员属性的值都相同时候,就是一个对象,就应该实现去重,
* 成员属性相同的Person对象只能放进去一个
*/ import java.util.HashSet; public class SetDemo02 {
public static void main(String[] args) {
HashSet hash=new HashSet();
hash.add("哈哈");
hash.add("哈哈");
hash.add("哈哈");
hash.add("哈哈");
hash.add("哈哈");
System.out.println(hash);//[哈哈]
}
}
```