Java-數組和集合簡單使用

數組和集合：

1.數組第一種定義方式

int[] counts = {1,2,3,4,5};

2.數組第二種定義方式(先初始化，后賦值)

int[] numbers = new int[3];
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[0] = 1000;//在索引范圍以內可以更改

3.數組創建第三種方式

int[] nums = new int[] {1,2,3};
//修改
nums[0] = 1000;

package com.steven.demo;

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

public class Test {

    public static void main(String[] args) {
        
        //java的八種數據類型
        //byte int long short -整型
        //float double -浮點型
        //boolean -布爾型
        //char 字符型
        int i = 1000;
        long l = 1000; 
        float f = l;
        System.out.println("Hello, world ~" + l + i + f);
        char c = 'A';
        System.out.println(c);
        char a = 'a';
        char zero = '0';
        System.out.println("a===" + a);
        System.out.println("zero = " + zero);
        
        //1.數組第一種定義方式
        int[] counts = {1,2,3,4,5};
        //獲取數組的第一個值 syso 打印快捷鍵
        System.out.println("數組的第一個值是" + counts[0]);//數組的第一個值是1
        //獲取數組的最后一個值
        int length = counts.length;
        System.out.println("數組的長度是"+length);//數組的長度是5
        System.out.println("數組的最后一個元素" + counts[length-1]);//數組的最后一個元素5

        float[] moneys = {1.5f,2.0f,3.0f};
        char[] cs = {'A','中','1','C'};
        System.out.println("浮點型數組"+moneys[1]);//2.0
        System.out.println("字符型數組"+cs[1]);//中
        
        //2.數組第二種定義方式(先初始化，后賦值)
        //int[] numbers = {};
        //Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
        //at com.steven.demo.Test.main(Test.java:39)
        int[] numbers = new int[3];
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[0] = 1000;//在索引范圍以內可以更改
        //numbers[3] = 4;//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
        System.out.println("numbers = " + numbers.length);//numbers = 3
        //數組一旦定義長度就不可以更改了
        
        //3.數組如何獲取值-for循環獲取值
       for (int j = 0; j < numbers.length; j++) {
           System.out.println("j==" + j);
           //j==0
           //j==1
           //j==2
       }
       int k = 0;
       for (int b : numbers) {
           System.out.println("numbers["+k+"]"+b);
           k++;
           //numbers[0]1000
           //numbers[1]2
           //numbers[2]3
       }
       //4.數組創建第三種方式
       int[] nums = new int[] {1,2,3};
       //修改
       nums[0] = 1000;
       System.out.println(nums[0]);
       System.out.println(nums.length); 
       
       //5.冒泡排序
       int[] ks = {1,3,34,56,78,33,3,56};
       for (int j = 0; j < ks.length; j++) {
        for (int b = 1; b < ks.length-1; b++) {
            System.out.println(ks[j]+"===="+ks[b]);
        }
        System.out.println("==============");
       }
       
       //6.動態數組
       //java.util.Collection
       //collection接口 --- list接口-- 一個動態數組
       //jdk里面的ArrayList和Vectory是動態數組
       //集合條件元素是調用:add(object);
       List<String> strings = new ArrayList<String>(); //等價於String[] str = new String[100];
       strings.add("1");
       strings.add("2");
       strings.add("3");
       strings.add("4");//添加到這一行：數組的長度編程9
       System.out.println("動態數組"+strings.size() + strings.getClass());//動態數組4class java.util.ArrayList
       //獲取元素的第一個值
       System.out.println("元素的第一個值"+strings.get(0));//元素的第一個值1
       System.out.println("元素的最后一個值"+strings.get(strings.size()-1));//元素的最后一個值4
       //修改
       strings.set(0, "1000");
       System.out.println("元素的第一個值是"+strings.get(0));//元素的第一個值是1000
       //刪除
       strings.remove(2);
       //可以賦值為空嗎？
       strings.set(0, null);
       strings.add(null);
       System.out.println("可以賦值為空嗎？"+strings.get(0));
       //取值
       //a.第一種 for each循環
       for (String string: strings) {
           System.out.println("string = " + string);
           //string = 1000
           //string = 2
           //string = 4
       }
       //b.第二種 for循環
       for (int j = 0; j < strings.size(); j++) {
          System.out.println(strings.get(j));
        }
       //c.第三種 迭代器
       Iterator<String> inerator = strings.iterator();
       while (inerator.hasNext()) {
           System.out.println(inerator.next());
        }
    }    
}

package com.steven.demo;

import java.util.ArrayList;
import java.util.Iterator;//迭代器
import java.util.List;

public class Test {

    public static void main(String[] args) {
        
        //1.數組是一種數據的集合
        //2.數組作為一種引用類型
        //3.數組是一種容器，可以用來存儲其他任意類型的元素
        //4.數組元素的類型可以是基本類型，也可以是引用類型，但同一個數組只能是同一種類型
        //5.數組的長度在在數組創建后就確定了，就無法修改了
        //6.數組分為：一維數組，二維數組，三維數組，多維數組
        
        //一、聲明數組語法
        /*
         1>.數組元素的類型[] 變量名稱
         2>.數組元素的類型 變量名稱[]
         數組元素的類型，可以使java中的任一類型，變量名稱可以是任意合法的標識符
         例：
         int[] a;
         Student[] students;
         在一行中也可以聲明多個數組, 例: int[] a,b,c
         * */
        
        //聲明一個一維數組，用來存儲int類型
        int[] i = {1,2,3};
        //boolean 類型數組
        boolean [] j = {true,false,true,false};
        //String類型數組
        String[] strings = {"Steven","HuSir"};
        //byte數組
        byte[] k = {1,2,3};
        //char數組
        char[] m = {'a','b'};
        //Object數組
       Object object1 = new Object();
       Object object2 = new Object();
       Object[] objects = {object1,object2};
       
       //數組創建兩種方式
       //第一種: 使用new 操作符來創建數組
       //格式為：new 數組元素的數據類型 [數組元素的個數]
       //基本類型的數組和引用類型的數組，必須清楚數組為引用類型，它在堆中分配。
    
       //聲明一個int類型的數組，數組長度為3
       int[] data = new int[3];
       //給數組中的元素賦值,如果不賦值默認為該類型的默認值，如果是int類型就為0；
       //賦值：變量名[下標] 下標從0開始
       data[0] = 1;
       data[1] = 2;
       data[2] = 3;
       for (int i1= 0; i1 < data.length; i1++) {
           System.out.println("下標為："+i1+"的值為："+data[i1]);
           //下標為：0的值為：1
           //下標為：1的值為：2
           //下標為：2的值為：3
       }
         
    }    
        
}

數組動態初始化和靜態初始化的選擇：

//什么時候使用動態初始化,什么時候使用靜態初始化?
//1.無論靜態初始化還是動態初始化,最終的內存分布都是一樣的如果在創建數組的時候,知道數組中應該存儲什么數據,這個時候當然采用靜態初始化方式
//2.如果在創建數組時,無法預測到數組中的存儲什么數據,只是先開辟空間,就是用動態初始化的方式進行創建

二維數組和多維數組以及冒泡排序

package com.steven.demo;

public class ArrayTest {
   public static void main(String[] args) {
     
    Student students = new Student();
    //二維數組的聲明和使用
    //二維數組屬於多維數組，什么是多維數組，當數組元素的類型是數組時就成了多維數組
    //二維數組的聲明格式
    //1.數組元素的數據類型[][] 變量名
    //2.數組元素的數據類型 變量名 [][] 
    //其中中括號的個數就是數組的維數
    //3.特殊的一維數組，(這個一維數組中每個元素都是一維數組)
    
    //1.聲明一個二維數組
    int [][] m = new int[2][3];
    //對二維數組賦值
    m[0][0] = 1;
    m[0][1] = 2;
    m[0][2] = 3;
    
    m[1][0] = 4;
    m[1][1] = 5;
    m[1][2] = 6;
    
    //輸出二維數組
    for (int i = 0; i < m.length; i++) {
        for (int j = 0; j < m[i].length; j++) {
            System.out.println("輸出二維數組" + m[i][j]);
        }
    }
    //2.二維數組的動態初始化
    //3個一維數組，每個一維數組中有四個元素
    int[][] a = new int [3][4];
    a[1][2] = 1000;
    //遍歷
    for (int i = 0; i < a.length; i++) {
        for (int j = 0; j < a[i].length; j++) {
            System.out.println(a[i][j] + " ");
        }
        System.out.print("\n");
    }
     
    //3.多維數組: 當數組元素的類型是數組時就成了多維數組
    
    int[][]n = new int[][] {{1,2,3},{4,5,6},{7,8,9}};
    //循環三次
    for (int i = 0; i < n.length; i++) {
        for (int j = 0; j < n[i].length; j++) {
            System.out.println(n[i][j]+ " ");
        }
        System.out.print("\n");
    }
    
    //4.冒泡排序
    int[] array = {3,1,6,2,5};
    System.out.println("數組的長度為"+array.length);
    //開始排序
    for (int i = array.length-1; i >0; i--) {
        for (int j = 0; j < i; j++) {
            if (array[j] > array[j+1]) {
                //交換位置
                int temp;
                temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;
            }
        }
    }
    //遍歷
    for (int i = 0; i < array.length; i++) {
        System.out.println("數組元素為"+array[i]);
    }
    
   }
}