Java基础学习(四) -- 数组

1、数组

数组指一组数据的集合，数组中的每个数据被称作元素。

2、数组定义

数组类型[] 数组名 = new 数组类型[元素个数或数组长度]；

String[] test1 = new String[6];
test1[0] = "数组0";
test1[1] = "数组1";

注意：等号前面的[]里面不能写任何东西。

简化格式定义：数组类型[] 数组名 = {元素，元素，....}；

String[] test2 = {"数组0","数组1","数组2","...."};

完整格式定义：数据类型 数组名称 = new 数据类型[] {值, 值,…}

String[] test3 = new String[]{"数组0","数组1","数组2","...."};

3、二维数组

• 二维数组中，a.length表示行数，a[i].length表示第i行的列数
• 动态初始化时，多维数组的行数不可省略，列数可省略

public class ArrayTest {
    public static void main(String[] args) {
        //动态初始化
        int[][] a = new int[2][3];
        a[0][0] = 2;
        a[1][2] = 5;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.print(a[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

4、对象数组

• 对象数组往往是以引用数据类型为主的定义，例如：类、接口
• 存放引用数据类型 - 通过类来创建的对象

4.1 初始化

//动态初始化
类名称[] 对象数组名称 = new 类名称[长度];
 
//静态初始化
类名称[] 对象数组名称 = new 类名称[] {};

public class ArrayOfObjects {
    //类方法
    public static void printArray(Person[] persons) {
        for (int i = 0; i < persons.length; i++) {
            System.out.println(persons[i]);
        }
    }
 
    public static void main(String[] args) {
        Person person = new Person(1, "张三");
        System.out.println(person);//person.toString(); //继承自Object
 
        String s = "Bonjour";  //引用类型
        System.out.println(s);  //s.toString();
 
        //动态初始化
        Person[] persons = new Person[3];
        persons[0] = new Person(1, "Jack");
        persons[1] = new Person(2, "Tom", "tom@gmail.com");
        persons[2] = new Person(3, "Alice", "alice@gmail.com", "15265478955");
        ArrayOfObjects.printArray(persons);
 
        //静态初始化
        Person[] persons2 = new Person[]{
                new Person(4, "Tony")
        };
        ArrayOfObjects.printArray(persons2);
    }
}
 
class Person {
    private int id;
    private String name;
    private String email;
    private String phone;
 
    //构造方法
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
 
    public Person(int id, String name, String email) {
        this(id, name);
        this.email = email;
    }
 
    public Person(int id, String name, String email, String phone) {
        this(id, name, email);
        this.phone = phone;
    }
 
    //getter方法
    public int getId() {
        return this.id;
    }
 
    public String getName() {
        return this.name;
    }
 
    public String getEmail() {
        return this.email;
    }
 
    public String getPhone() {
        return this.phone;
    }
 
    //setter方法
    public void setEmail(String email) {
        this.email = email;
    }
 
    public void setPhone(String phone) {
        this.phone = phone;
    }
 
    public String toString() {
        return " 编号：" + this.id + " 姓名：" + this.name + " 邮箱：" + this.email + " 电话：" + this.phone;
    }
}

5、工具类 Array

Java中最基本的一个存储结构。提供了动态创建和访问 Java 数组的方法。其中的元素的类型必须相同。效率高，但容量固定且无法动态改变。

6、工具类 Arrays

Arrays类是Java 中提供的一个工具类，在 java.util 包中。该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等。此类还包含一个允许将数组作为列表来查看的静态工厂。

常用方法：

1.声明数组
2.初始化数组
3.遍历数组 for(int temp: a)
4.拷贝数组 System.arraycopy(a,0,b,0,6)
5.复制数组 Arrays.copyOf(a)返回新数组
6.打印数组 Arrays.toString(a)
7.填充数组 Arrays.fill(a, , ,key)
8.排序数组 Arrays.sort(a,0,6)
9.二分法查找 Arrays.binarySearch(a,key）
10.比较数组 Arrays.equals(a,b)
11.包含某一个值 Arrays.asList(a).contains(b)
12.转成arraylist  ArrayList al = new ArrayList(Arrays.asList(a));
13.转成set集合  Set set= new HashSet(Arrays.asList(a));
14.转成list集合  List list=java.util.Arrays.asList(a)
15.去重复 .

7、工具类 ArrayList

ArrayList类存放同一数据类型的容器(只能是引用数据类型，因其实际内部存放的是地址)， 是一个数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

• ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
• ArrayList 实现了RandmoAccess接口，即提供了随机访问功能。RandmoAccess是java中用来被List实现，为List提供快速访问功能的。在ArrayList中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。
• ArrayList 实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
• ArrayList 实现java.io.Serializable接口，这意味着ArrayList支持序列化，能通过序列化去传输。
• 和Vector不同，ArrayList中的操作不是线程安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。

7.1 创建对象

格式： ArrayList<E> 对象名=new ArrayList<>();

E：泛型 数据类型，指定对象名中存放指定类型的数据，不可省略，需为引用数据类型

import java.util.ArrayList;
import java.util.Random;
//定义方法将大集合中20个随机数，其中是偶数的放入小集合中
public class DemoTest {

    public static void main(String[] args) {
        ArrayList<Integer> biglist = new ArrayList<>();
        ArrayList<Integer> smalist = new ArrayList<>();
        mythod(biglist, smalist);
    }

    public static void mythod(ArrayList<Integer> a, ArrayList<Integer> b){
        Random r = new Random();
        for (int i = 0; i < 20; i++) {
            int digit = r.nextInt(50);
            a.add(digit);
            if(a.get(i)%2 == 0){
                b.add(digit);
            }
        }
        System.out.println(a);
        System.out.println(b);
    }
}

7.2 常用操作

7.2.1 增加元素

add(E e)：添加一个元素到列表的末尾
add( int index, E element ) :在指定的位置添加元素
addAll( Collection<? extends E> c )：添加一个集合到元素的末尾.以上返回类型是boolean
ensureCapcity（int minCapcity）：确保列表中含有minCapcity的最小容量

7.2.2 删除元素

remove(Object o)：删除列表中第一个出现O的元素
remove( int index)：删除列表中指定位置的元素
removeAll（Collection<?> c）：删除列表中包含C的所有元素
removeIf（Predictcate<? super E> filter）：删除列表中给定谓词的所有元素
removeRange( int from,int to )：删除从from到to的所有元素
clear（）：清除所有的元素。返回类型为void

7.2.3 更改元素

retainAll( Collection<?> c )：仅仅保留列表中和C相同的元素，相当于&运算
set(int index,E element)：用element替换index位置上的元素
size()：返回此列表的元素数
sort(Comparator<? super E> c)：按照指定的排序规则排序
subList( int from , int to )：返回从from到to之间的列表
toArray()：将列表转化为数组
trimToSize( )：修改当前实例的容量是列表的当前大小

7.2.4 查找元素

contains(Object o)：如果包含元素o,则返回为true
get(int index):返回指定索引的元素
indexOf( Object o )：返回此列表中指定元素的第一次出现的索引，如果列表不包含此元素，返回-1
lastindexOf( Object o ):返回此列表中指定元素的最后一次出现的索引，如果列表不包含此元素，返回-1
isEmpty()：如果列表为空，返回true.
iterator()：返回列表中元素的迭代器
listIterator()：返回列表的列表迭代器（按适当的顺序）
listIterator(int index)：从适当的位置返回列表的列表迭代器(按照正确的顺序)

7.3 遍历

package Demo;

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

/**
 * Created by IDEA
 *
 * @author gengpengshuai
 * @date 2020-02-11 10:19
 */
public class ArrayListTest {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("周芷若");
        list.add("张无忌");
        list.add("张翠山");
        list.add("宋清书");

        //第一种遍历方式：迭代器
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }

        //第二种遍历方式：效率最高
        for (int i = 0; i < list.size(); i++) {
            String str = list.get(0);
            System.out.println(str);
        }

        //第三种方式：for
        for (String a:list) {
            System.out.println(a);
        }
    }
}

7.4 ArrayList  VS 数组

7.5 ArrayList VS LinkList、Vector

• ArrayList 本质上是一个可改变大小的数组.当元素加入时,其大小将会动态地增长.内部的元素可以直接通过get与set方法进行访问.元素顺序存储 ,随机访问很快，删除非头尾元素慢，新增元素慢而且费资源 ,较适用于无频繁增删的情况 ,比数组效率低，如果不是需要可变数组，可考虑使用数组 ,非线程安全。
• LinkedList 是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList. 适用于 ：没有大规模的随机读取，有大量的增加/删除操作.随机访问很慢，增删操作很快，不耗费多余资源 ,允许null元素,非线程安全。
• Vector （类似于ArrayList）但其是同步的，开销就比ArrayList要大。如果你的程序本身是线程安全的，那么使用ArrayList是更好的选择。 Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间，而ArrayList每次对size增长50%。

7.6 总结

ArrayList自己实现了序列化和反序列化的方法，因为它自己实现了private void writeObject(java.io.ObjectOutputStream s)、private void readObject(java.io.ObjectInputStream s) 方法
ArrayList基于数组方式实现，无容量的限制（会扩容）
添加元素时可能要扩容（所以最好预判一下），删除元素时不会减少容量（若希望减少容量，trimToSize()），删除元素时，将删除掉的位置元素置为null，下次gc就会回收这些元素所占的内存空间。
线程不安全，会出现fall-fail。下一篇文章会详细讲，
add(int index, E element)：添加元素到数组中指定位置的时候，需要将该位置及其后边所有的元素都整块向后复制一位
get(int index)：获取指定位置上的元素时，可以通过索引直接获取（O(1)）
remove(Object o)需要遍历数组
remove(int index)不需要遍历数组，只需判断index是否符合条件即可，效率比remove(Object o)高
contains(E)需要遍历数组
使用iterator遍历可能会引发多线程异常