JavaSE基础（集合：数组、Collection、List（ArrayList、LinkedList、Vector）、Set（HashSet、TreeSet）、Map（HashMap））

一、数组

注意：Java数组只能存放8种基本数据类型（byte、short、int、long、float、double、char、boolean)

数组声明：

        DataType [ ] arrayName = new DataType [ ArraySize ];

        DataType [ ] arrayName = {element1,element2,element3....,elementn};

        DataType [] arrayName = new DataType[]{element1,element2,element3,....,....,.....,elementn}

遍历数组：

//数组的声明

//声明方式一
int [] intArray = new int[length];
//声明方式二
char [] charArray = {'h','l','l','o'}
//声明方式三
int [][] intTwoArray = new int[3][3];

//For循环遍历数组

for(int i=0;i<array.lenght;i++){
    System.out.println(array[i]);
}

//For-Each循环遍历数组

for(int element : array){
    System.out.println(element);
}

//记住toString()函数  deepToString()函数

Arrays.toString(charArray);

Arrays.deepToString(intTwoArray);

多维数组：

        DataType [ ][ ] arrayName = new DataType[ ][ ]

private int[][] intArray = new int[5][5];

for(int i=0;i<intArray.length;i++){
    for(int j=0;j<intArray[i].length;j++){
        intArray[i][j] = i*j;
    }
}

Arrays（java.util.Arrays）类常用方法

toString()  /  sort()  /  fill()  /  copyOf()  /  binarySearh()  /  asList()

1、Arrays.toString( arrayName)   将数组转换为字符串可以直接输出

private boolean [] booleanArray = new boolean[10];

for(int i=0;i<booleanArray.length;i++){
    if(i%2 == 0){
        booleanArray[i] = true;
    }else{
        booleanArray[i] = false;
    }
}

System.out.println(Arrays.toString(booleanArray));

//输出结果：[true, false, true, false, true, false, true, false, true, false]

2、数组填充

Array.s.fill(intArray,20)

3、数组排序

Arrays.sort()        排列如果是数值，sort默认按照升序从小到大；如果是字符串，sort默认按照字母的升序

private int [] intArray = new int[10];


for(int i=0;i<intArray.length;i++){
    intArray[i] = (int)(Math.random()*1000);
}

Arrays.sort(intArray);

System.out.println(Arrays.toString(intArray));

4、复制数组

Arrays.copyOf()

private int [] intArrayCopy = Arrays.copyOf(intArray,10);

5、查找数组元素返回索引

Arrays.binarySearch(int[] arr, int key)        底层采用二分法查找key的索引并返回，前提是数组必须是有序的

int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9,10};
int Index = Arrays.binarySearch(arr, 11);
System.out.println(Index);        9
System.out.println(Index);        -11 = (-10-1)  如果元素不存在，返回值为元素应在的

6、转换为ArrayList 将数组转换为ArrayList集合

Arrays.asList()

  
private String [] stringArray = new String[10]; 
private List<String> stringArrayList = new ArrayList<>();
    
for(int i=0;i<stringArray.length;i++){
   stringArray[i] = "Hello World";
}

stringArrayList = Arrays.asList(stringArray);

常见数组排序法

1、冒泡排序

2、

数组和集合的对比：

提到集合之前，先说说数组Array和集合的区别：

 　　(1)数组是大小固定的，并且同一个数组只能存放类型一样的数据（基本类型/引用类型）

 　　(2)JAVA集合可以存储和操作数目不固定的一组数据。

　　　(3)若程序时不知道究竟需要多少对象，需要在空间不足时自动扩增容量，则需要使用容器类库，array不适用。　　

　        使用相应的toArray()和Arrays.asList()方法可以相互转换。

        数组：

                数组的长度不可变

                数组中无法查看数组中有效元素个数的方法

        集合：

                集合的长度是可变的

                集合中可以存储任意类型对象，也只能存储对象

二、集合（List（列表）、Set（集）、Map（映射））

Java集合框架主要包括（List列表、Set集、Map映射）

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

参考文章：Map、Set、List集合差别及联系详解 - kosamino - 博客园

参考文章：List、Map、Set之间的联系和区别_IUDN的博客-CSDN博客

List（列表） 和 Set（集）：

Map（映射） ：

Collection

如何遍历Collection中的每一个元素 不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：

java.util.Collection

        |--- java.util.List  整个List接口都有索引值 

                |--- java.util.ArrayList     采用数组结构存储元素  查询效率高 查询多的时候使用  使用索引查询较快

                |--- java.util.LinkedList   采用链表结构存储元素  增删效率高  查询效率低

                |--- java.util.Vector

        |--- java.util.Set

                |--- java.util.HashSet

                |--- java.util.TreeSet

List 有序元素集合（存储是有序的（每个元素都有索引值）、允许有重复元素）

Set 不允许重复元素集合（不允许有重复元素）

java.util.Collection 集合层次的跟接口

        add()    clear()     size()      remove()  

java.util.List

collection接口的实现类 ArrayList类 (java.util.ArrayList)

package arraylisttest;

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

public class ArrayListTest{
    public static void main(String [] args){
        ArrayListFunction arrayListFunction = new ArrayListFunction();
        arrayListFunction.test();
    }
}
class ArrayListFunction{
    public void test(){
        List<String> arrayList = new ArrayList<String>();

        //add() 添加元素
        arrayList.add("Hello Java");
        arrayList.add("Hello PHP");
        arrayList.add("Hello Python");
        arrayList.add("Hello JavaScript");
        
        //size() 获取ArrayList长度
        for(int i=0;i<arrayList.size();i++){
            //get(index)获取指定索引位置的元素
            System.out.println(arrayList.get(i));
        }
    }
}

LinkedList类 (java.util.LinkedList)

HashSet类（java.util.HashSet)

package hashsettest;

import java.util.Set;
import java.util.HashSet;

public class HashSetTest{
    public static void main(String [] args){
        HashSetFunction hashSetFunction = new HashSetFunction();
        hashSetFunction.test();
    }
}

class HashSetFunction{
    public void test(){
        Set<String> stringSet = new HashSet<String>();
        //add()
        stringSet.add("Hello World");

        //size()
        System.out.println(stringSet.size());

        //isEmpty()
        System.out.println(stringSet.isEmpty());
    }
}

HashMap类（java.util.HashMap)

package hashmaptest;

import java.util.Map;
import java.util.HashMap;

public class HashMapTest{
    public static void main(String [] args){
        HashMapFunction hashMapFunction = new HashMapFunction();
        hashMapFunction.test();
    }
}

class HashMapFunction{
    public void test(){
        Map<String,Object> user = new HashMap<String,Object>();

        //put(key,value)
        user.put("name","xujingliang");
        user.put("age",20);
        //clear()

        //clone()

        //isEmpty()
        
        //size()
        
        //get(key)
        System.out.println(user.get("name"));
        System.out.println(user.get("age"));

    }
}