Java-数组和集合简单使用

Posted 2021-02-19 sunny123456

原文链接 https://www.cnblogs.com/StevenHuSir/p/Java_ArrayAndSet.html

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

}
}