length函数java数组_数组 Array-java

Java 数组

重要的数据结构之一，用来存储固定大小的同类型元素

数组声明

创建数组

处理数组

for-each

数组作为函数的参数

数组作为函数的返回值

多维数组

Arrays类

数组声明

语法格式：

dataType[] arrayRefvar;//首选方法

//或者

dataType arrayRefVar[];

创建数组

通过new来创建数组

arrayRefVar = new dataType[arraySize];

dataType[arraysize]创建了一个数组

把新创建的数组引用赋值给变量arrayRefVar

声明和创建一条语句完成

dataType[] arrayRefVar = new dataType[arraySize]

或者

dataType[] arrayRefVar = {value0,value1,value2...};

数组元素通过下标索引访问的。

示例：包含十个double数据类型元素的数组

public classTestArray {public static voidmain(String[] args) {//数组大小

int size = 10;//定义数组

double[] myList = new double[size];

myList[0] = 5.6;

myList[1] = 4.5;

myList[2] = 3.3;

myList[3] = 13.2;

myList[4] = 4.0;

myList[5] = 34.33;

myList[6] = 34.0;

myList[7] = 45.45;

myList[8] = 99.993;

myList[9] = 11123;//计算所有元素的总和

double total = 0;for (int i = 0; i < size; i++) {

total+=myList[i];

}

System.out.println("总和为： " +total);

}

}

处理数组

数组元素的类型和数组大小都是确定的，通常使用for-each循环

示例

public classTestArray {public static voidmain(String[] args) {double[] myList = {1.9, 2.9, 3.4, 3.5};//打印所有数组元素

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

System.out.println(myList[i]+ " ");

}//计算所有元素的总和

double total = 0;for (int i = 0; i < myList.length; i++) {

total+=myList[i];

}

System.out.println("Total is " +total);//查找最大元素

double max = myList[0];for (int i = 1; i < myList.length; i++) {if (myList[i] > max) max =myList[i];

}

System.out.println("Max is " +max);

}

}

for-each

jdk1.5引进的一种新的循环类型，被成为for-each循环或增强for循环，可以不通过下标遍历数组。

语法格式：

for(type element:array){

System.out.println(element);

}

示例

public classTestArray {public static voidmain(String[] args) {double[] myList = {1.9, 2.9, 3.4, 3.5};//打印所有数组元素

for (doubleelement: myList) {

System.out.println(element);

}

}

}

数组作为函数的参数

示例

public static void printArray(int[] array) {for (int i = 0; i < array.length; i++) {

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

}

}

数组作为函数的返回值

示例

public static int[] reverse(int[] list) {int[] result = new int[list.length];for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {

result[j]=list[i];

}returnresult;

}

多维数组

即是数组的数组。

多维数组动态初始化

语法格式：type[] typeName = new type[typeLength1][typeLength2];

type可以是基本数据类型和复合数据类型

例如：int a[][] = new int[3][2];

多维数组的引用

语法格式：arryName[index0][index1]

例如：num[1][2];

Arrays类

可以更方便的操作数组，提供的方法都是静态的

给数组赋值：fill方法

数组排序：sort方法，升序

比较数组：通过equals方法比较数组中元素值是否相等

查找数组元素：通过binarySearch方法能对排序好的数组进行二分法操作

编号方法说明

1

public static binarySearch(Object[] a ,Object key)

用二分法查找，数组使用前必须是排序好的，在数组中返回下标

2

public static boolean equals(Long[] a, Long[] a2)

指定两个类型相同的数组，如果包含同等数量元素，并且所有元素都是对等的，则是真

3

public static void fill(int[] a,int val)

将指定的int值分配给指定int类型数组指定范围中的每个元素。

4

public static void sort(Object[] a)

对指定对象数组根据其元素的自然顺序进行升序排列

练习案例

1. 倒序练习

public classTest2 {public static voidmain(String[] args){int[] test= {1,2,4,5,7};for (inti : test) {

System.out.print(i+" ");

}

System.out.println("\n");

test=Test2.reverse(test);for (inti : test) {

System.out.print(i+" ");

}

}public static int[] reverse(int[] arr){int[] result = new int[arr.length];for (int i = 0,j=result.length-1; i < arr.length; i++,j--) {

result[j]=arr[i];

}returnresult;

}

}

2. 数组和字符串的转换

public classTest {public static voidmain(String args[]) {

String str= "helloworld";char[] data = str.toCharArray();//将字符串转为数组

for (int x = 0; x < data.length; x++) {

System.out.print(data[x]+ " ");

data[x]-= 32;

System.out.print(data[x]+ " ");

}

System.out.println(newString(data));

}

}

3. 冒泡排序

public classBubbleSort {/*** N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i)次，所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数。

*@paramargs*/

public static voidmain(String[] args) {int arr[] = {26,15,29,66,99,88,36,77,111,1,6,8,8};for(int i=0;i < arr.length-1;i++) {//外层循环控制排序趟数

for(int j=0; j< arr.length-i-1;j++) {//内层循环控制每一趟排序多少次//把小的值交换到前面

if (arr[j]>arr[j+1]) {int temp =arr[j];

arr[j]= arr[j+1];

arr[j+1] =temp;

}

}

System.out.print("第"+(i+1)+"次排序结果：");//列举每次排序的数据

for(int a=0;a

System.out.print(arr[a]+ "\t");

}

System.out.println("");

}

System.out.println("最终排序结果：");for(int a = 0; a < arr.length;a++) {

System.out.println(arr[a]+ "\t");

}

}

}

4. 选择排序

public classStart

{public static voidmain(String[] args)

{int[] arr={20,60,51,81,285,12,165,51,81,318,186,9,70};for(inta:arr)

{

System.out.print(a+" ");

}

System.out.println("\n"+"---------------从小到大---------------");

arr=toSmall(arr);for(inta:arr)

{

System.out.print(a+" ");

}

System.out.println("\n"+"---------------从大到小---------------");

arr=toBig(arr);for(inta:arr)

{

System.out.print(a+" ");

}

}//从大到小

public static int[] toSmall(int[] arr)

{//遍历数组里除最后一个的其他所有数，因为最后的对象没有与之可以相比较的数

for(int i=0;i

{/*遍历数组里没有排序的所有数，并与上一个数进行比较

*“k=i+1”因为自身一定等于自身，所以相比没有意义

*而前面已经排好序的数，在比较也没有意义*/

for(int k=i+1;k

{if(arr[k]

{int number=arr[i];

arr[i]=arr[k];

arr[k]=number;

}//交换

}

}returnarr;

}//从小到大//和前面一样

public static int[] toBig(int[] arr)

{for(int i=0;i

{for(int k=i+1;k

{if(arr[k]>arr[i])

{int number=arr[i];

arr[i]=arr[k];

arr[k]=number;

}

}

}returnarr;

}

}

arrays方法使用

importjava.util.Arrays;public classTestArrays {public static void output(int[] array) {if (array != null) {for (int i = 0; i < array.length; i++) {

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

}

}

System.out.println();

}public static voidmain(String[] args) {int[] array = new int[5];//填充数组

Arrays.fill(array, 5);

System.out.println("填充数组：Arrays.fill(array, 5)：");

TestArrays.output(array);//将数组的第2和第3个元素赋值为8

Arrays.fill(array, 2, 4, 8);

System.out.println("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");

TestArrays.output(array);int[] array1 = { 7, 8, 3, 2, 12, 6, 3, 5, 4};//对数组的第2个到第6个进行排序进行排序

Arrays.sort(array1, 2, 7);

System.out.println("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");

TestArrays.output(array1);//对整个数组进行排序

Arrays.sort(array1);

System.out.println("对整个数组进行排序：Arrays.sort(array1)：");

TestArrays.output(array1);//比较数组元素是否相等

System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):" + "\n" +Arrays.equals(array, array1));int[] array2 =array1.clone();

System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):" + "\n" +Arrays.equals(array1, array2));//使用二分搜索算法查找指定元素所在的下标(必须是排序好的，否则结果不正确)

Arrays.sort(array1);

System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)：" + "\n" + Arrays.binarySearch(array1, 3));//如果不存在就返回负数

System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)：" + "\n" + Arrays.binarySearch(array1, 9));

}

}