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("
");
    }
     
    //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("
");
    }
    
    //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]);
    }
    
   }
}