《java学习笔记》之数组

数组

---

一. 一维数组

1.1一维数组基础语法

//数组

public class ArrayTest01 {

public static void main(String[] args) {

//数组的定义(数组一旦创建数组长度不可变)

//原则：什么时候用静态初始化的方式，什么时候采用动态的初始方式？

// 当你创建数组的时候，确定数组中存储的具体元素时，采用静态初始化的方式

// 当你创建数组的时候，不确定将来数组中存储哪些具体数据，可以采用动态初始化的方式，预先分配内存空间

//静态初始化

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

//所有数组对象都有length属性（java自带的），用来获取数组中元素个数。

System.out.println(array1.length);//5

//动态初始化

int[] array2 =new int[10];

System.out.println(array2.length);//10

//遍历数组

for (int i = 0; i < array1.length; i++) {

System.out.println(array1[i]);

}

//调用参数为数组的方法遍历数组

printArray(array2);

//还可以这样

printArray(new int[]{1,2,3});

//查询数组某个位置上的元素

//数组首位是从零开始的

//数组中每个元素都是有下标的，下标从0开始，

// 以1递增。最后一个元素的下表是：length - 1。

System.out.println(array1[0]);

//越界了会怎么样

//System.out.println(array1[5]);//java.lang.ArrayIndexOutOfBoundsException

}

//创建一个方法，参数是数组，遍历数组

public static void printArray(int[] array){

//增强for循环

for(int i:array){

System.out.println(i);

}

}

}

1.2 public static void main(String[] args)中的String[] args

public class ArrayTest02 {

//这个方法程序员写，JVM调

public static void main(String[] args) {

//JVM默认传过来的数组长度是0

//通过测试args不是null,如果是null就会有空指针异常

System.out.println("JVM传过来的args数组参数，这个数组长度是？ " + args.length);

//遍历 args

for (int i = 0; i <args.length ; i++) {

System.out.println(args[i]);

}

/*

在cmd中运行就是：

例如这样运行程序： java ArrayTest05 abc efg hrj

那么这个时候JVM就会自动将abc efg hrj通过空格的方式分离，自动放到“String[] args”中

所以main方法上的 String[] args 数组主要是来接受客户输入的参数的

abc efg hrj 变成 {“abc”,“efg”,“hrj”}

*/

}

}

什么都不做处理

但是其实可以传数据给args数组

在IDEA中是这样操作的：

run–>Edit Configurations–>Program arguments 写参数，逗号隔开例如：

运行结果就变成了：

按照上面的方法在Program arguments 里面填取 小明 123 就可以正确执行了

/*

模拟一个系统，假设该系统要使用，必须输入用户名和密码(通过args来)

*/

public class ArrayTest03 {

public static void main(String[] args) {

//用户名和密码是两组数，所以args.length 会为2

if(args.length != 2){

System.out.println(“请输入用户名和密码”);

return;

}

//执行到这说明输入了用户名和密码

if (“小明”.equals(args[0]) && “123”.equals(args[1])){

System.out.println(“密码正确”);

System.out.p
rintln(“欢迎 " + args[0] + " 使用”);

}else{

System.out.println(“用户名或密码错误”);

return;

}

}

}

1.3 数组的扩容

/*Java中数组的扩容：

先新建一个大容量数组，然后将小容量的数据一个一个拷贝到大数据当中。

*/

public class ArrayTest04 {

public static void main(String[] args) {

//怎么进行拷贝？

//System.arraycopy(五个参数);

//拷贝源

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

//拷贝目标(拷贝到目标数组上)

int[] array2 = new int[10];

//拷贝

System.arraycopy(array1,1,array2,1,3);

//遍历

for (int i: array2){

System.out.print(i + " ");//0 1 2 3 0 0 0 0 0 0

}

System.out.println();

//完全拷贝

System.arraycopy(array1,0,array2,0,6);

for(int i:array2){

System.out.print(i + " ");//0 1 2 3 4 5 0 0 0 0

}

}

}

二. 二维数组

//二维数组

public class ArrayTest05 {

public static void main(String[] args) {

//静态初始化

int[][] array1={

{1,2,3},

{4,5},

{6,7,8,9,10},

};

//动态初始化

int[][] array2 = new int[3][4];

//二维数组的读和写

//二维数组的第三个一维数组的第三个元素

System.out.println(array1[2][2]);//8

array2[2][1] =3;

System.out.println(array2[2][1]);//3

//二维数组的遍历

for (int i = 0; i < array1.length; i++) {//负责纵行

for (int j = 0; j < array1[i].length; j++) {//负责横行

System.out.print(array1[i][j]+ " ");

}

//输出一行就换行

System.out.println();

}

}

}

三. 数组工具类Arrays

3.1。排序算法

import java.util.Arrays;

//Arrays是Sun公司提供的数组工具类

//java.util.Arrays

public class ArrayTest06 {

public static void main(String[] args) {

//例如排序

int[] array1 = {8,3,4,5,1,9,2,3,6,0};

/Arrays.sort(array1);/

/BubbleSort(array1);/

SelectSort(array1);

//遍历

for (int i = 0; i < array1.length; i++) {

System.out.print(array1[i] + " ");//0 1 2 3 3 4 5 6 8 9

}

}

//我们可以尝试自己定义排序算法

//冒泡算法java代码实现

/**

• 冒泡排序java实现

• @param array 目标数组

• @return 已排序数组

冒泡排序算法

• 1.每一次循环，都要找到最大的那个数字，放到参与比较的这堆数据的最右边。

• 2.核心

•   拿着左边的数字和右边的比较，当左边>右边的时候，交换位置
  

*/

public static int[] BubbleSort(int[] array){

for (int n = array.length - 1; n >= 0 ; n–){

for (int i= 0; i < n ; i++) {

//比较

if (array[i] > array[i + 1]){

//交换，大的往右边放

int temp = array[i];

array [i] = array[i+1];

array[i+1] = temp;

}

}

}

return array;

}

//选择算法java实现

//循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和最前面的数据“交换位置”

public static int[] SelectSort(int[] array){

for (int i = 0; i < array.length -1; i++) {

//假定最小的是最前面的

int min = i;

//找出最小项的下标

for (int j = i + 1; j <= array.length -1; j++) {

//如果有比min小的

if (array[j] < array[min]){

min = j;

}

}

//如果i不是最小的

if (i != min){

//交换

int temp = array[i];

array[i] = array[min];

array[min] = temp;

}

}

return array;

}

}

3.2 查找算法

/*

• 数组元素查找

• 两种方式：

•   第一种方式：一个一个找，直到找到为止
  

•   第二种方式：二分法查找，这个效率高
  

• */

public class ArrayTest07 {

public static void main(String[] args) {

int[] array1 = {8,3,4,5,1,9,2,3,6,0};

System.out.println(“该元素在数组” + (arraySearch(array1,6) >= 0 ? “第”+ arraySearch(array1,6) + “位” : “不存在”) );

//该元素在数组第8位

//二分法要先排序

int[] array2 ={0,1,2,3,4,5,6,7,8,9,10};

System.out.println(“该元素在数组” + (binarySearch(array2,6) >= 0 ? “第”+ binarySearch(array2,6) + “位” : “不存在”) );

//该元素在数组第6位

}

//一个一个找，直到找到为止

/**

• @param array 要查找的数组

• @param dest 要查找的元素

• @return 如果返回非负数表示数组下标，返回负数代表不存在

*/

public static int arraySearch(int[] array,int dest){

for (int i = 0; i < array.length; i++) {

if (array[i] == dest){

return i;

}

}

return -1;

}

//二分法查找

/**

• @param array 要查找的数组

• @param dest 要查找的元素

• @return 如果返回非负数表示数组下标，返回负数代表不存在

*/

public static int binarySearch(int[] array,int dest){

//开始下标

int begin = 0;

//结束下标

int end = array.length -1;

while(begin <= end){

int mid = (begin + end)/2;

if (mid == dest){

return mid;

}else if (mid < dest){

begin = mid + 1;

}else if (mid > dest){

end = mid -1;

}

}

return -1;

}
}