java 数组和集合_Java-数组和集合简单使用

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 strings = new ArrayList(); //等价于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 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]);

}

}

}