Java数组

目录

定义 

一维数组 

数组定义三部曲

使用数组

元素复制三路径

数组排列（不能对布尔型数组排列）

数组工具类Arrays

 在方法中的应用

二维数组

定义

属性

普通二维数组

交错数组或变长数组

应用

数组重难点 

重点

难点

异常语言：

1.数组索引越界异常

 2.调用可变参数时的异常

---

定义 

一种容器，一种集合，存储相通数据类型的数据

一旦定义，个数和长度就确定了 

一维数组 

数组定义三部曲：

声明	数组名称和元素数据类型 eg.  int  []word;(声明不能指明数组元素个数)	int [ ] num; int num [ ]; int x[ ],y; int [ ]x,y;
创建	为元素分配储存空间 eg.  word  =  new  int[6];(数组大小可以在运行时指定)	num=new int[5]; x=new int[3]{1,2,3};
初始化	为元素赋值 eg.  int[]  word  =  {1,2,3,4,5,6};(这个方法不能指定数组的大小)	动态初始化 1.int [ ]num = new int[3]; 2.默认初始值
		静态初始化 1.int [ ]num = {1,2,3}; 2.int [ ]num = new int[ ]{1,2,3};

使用数组：

数组的输入储存	word[2]=3;	为数组元素分配引用空间
数组大小	word.length	public class ArrayDemo{ public static void main(String[] args){ int[] word=new int[6];//数组的构建和声明 word[0]=1; word[1]=2; word[2]=3; word[3]=4; word[4]=5; word[5]=6;//为元素赋初值 System.out.println(word[2]);//访问特定元素 System.out.println(word.length);//统计数组长度 for (int i=0;i<word.length;i++){ System.out.print(word[i]+" ");//通过数组长度依次访问数组元素 } } }

元素复制三路径：

for循环	逐个复制	int[] words={1,2,3,4}; int[] makes=new int[words.length];//定数组长度 for(int i=0;i<words.length;i++){ makes[i]=words[i];//对应赋值 System.out.print("makes[i]") }
System,arraycopy()	在for循环上有所进化	int[] words={1,2,3,4}; int[] makes=new int[words.length]; System.arraycopy(words,0,makes,0,4); /*(源数组，源数组起始下标， 目的数组，目的数组复制起始下标，复制元素个数)*/
Arrays.copyOf() 或  copyOfRange （10个重载的copeOf方法）		int[] words={1,2,3}; int[] newArray=Arrays.copyOf(words,4);//将源数组放到新数组中 wards=Arrays.copyOf(wards,4);//将新数组重新赋给原来的量
		char[] words={'a','b','c'.'d','e','f','g'}; words=Arrays.copyOfRange(words,1,5); //改变了words的长度

10个copeOf()重载的方法： 

数组排列（不能对布尔型数组排列）：

排列算法	冒泡法排序	#include<stdio.h> int main(void) { int n,i,j,x; int a[5]={6,4,5,2,1};//为需要排序的数字赋值 printf("对6，4，5，2，1五个数进行冒泡排序")； for(i=1;1<5:i++)//循环次数，保证数列各元素都被访问 { for(j=4;j>=i;j--) if(a[j]<a[j-i])//比较 { x=a[j]; a[j]=a[j-i]; a[j-i]=x;//交换顺序 } } printf("排序结果为：\n"); for(i=0;i<5;i++) printf("%2d",a[i]);//依次输出 return 0; } 这是C语言代码试着写出Java语言吧
	选择法排序	#include<stdio.h> #include<stdlib.h> #include<time.h> void main(void) { int n,i,j,k,x,min,a[100]; printf("请输入需要排列的数据个数："); scanf("%d",&n); srand((unsigned)time(NULL));//防止伪随机数的出现 printf("利用随机数生成函数生成%d个数："，n); for(i=0;i<n;i++) { a[i]=rand()%100; printf("%d",a[i]); }//生成随机数并输出 for(i=0;i<n-1;i++) { min=a[i]; k=i; for(j=i;j<n;j++) if(a[j]<min) { min=a[j]; k=j; } x=a[k]; a[k]=a[i]; a[i]=x; } printf("\n经过选择法排序后：\n"); for(i=0;i<n;i++) printf("%4d",a[i]); printf("\n"); } 这是C语言代码试着写出Java语言吧
数组工具类Arrays	在java.util.*的类包中；值处理一维数组
	Arrrays.sort(数组名)	从小到大排序
	Arrays.toString(数组名)	[元素1，元素2...]

 在方法中的应用：

作为方法参数	数组对象作为参数传递给方法（注意：如果在方法体中修改了数组元素的值，则会反映大奥返回的数组对象）	public static double sumArray(double array[]){ double sum=0; for(int i=0;i<array.length;i++) sum=sum+array[i]; return sum; }//求和
作为方法返回值	一个方法返回一个数组对象	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]; } return result; }//数组反转 使用时这样用： int[] list = {6,7,8,9,10}; init[] list2 = reverse(list); 这样就可以使用方法块啦
可变参数方法	在最后一个参数的类型名之后，参数名之前，使用省略号：public static double average(double ... values){ //方法体 }	package com.demo; public class VarargsDemo{ public static double average(double ... values){//可变参数 double sum = o; for(double value:values){//指value可变 sum = sum + value; }//方法体用于求和 double average = sum / values.length;//求平均数 return average;//返回值 } public static void main(String[] args){ System.out.println(average(50,70,86)); } } 可变参数是可选的

二维数组：

定义：

（存出一维数组的一维数组）

声明	int[][]  words;
创建	new  int[3][4]; int [][]wors = new int[2][3];
访问元素	words[i][j]	for(int i=0;i<matrix.length;i++){ for(int j=0;j<matrix[0].length;j++){ System.out.print(matrix[i][j]+" ");//访问元素 } System.out.println(); }
初始化器	int[][]  words={{1,2,3},{4,5}};

属性：

length——二维数组有多少行

普通二维数组：

int [ ][ ] x1=new int[3][4];——翻译为三行四列的表格

交错数组或变长数组：

int [ ][ ] y=new int[3][];

y[0]=new int[3];

y[1]=new int[5];

y[2]=new int[9];

应用：

排序：冒泡法和选择法

杨辉三角：

int [][] yh=new int[9][];
for(int i=0;i<yh.length;i++){
    yh[i]=new int[i+1];
    for(int j=0;j<yh[i].length;j++){
        if(j==0 || i==j)
            yh[i][j]=1;
        else{
            yh[i][j]=yh[i-1][j]+yh[i-1][j-1];
        }
        System.out.print(yh[i][j] + "  ");
    }
    System.out.println();
}

数组重难点 

重点：

1.数组的创建与使用

2.数组元素的迭代和复制

3.数组参数和返回值

4.Arrays类的常用方法

5.二维数组的使用

难点：

1.可变参数的方法

2.不规则二维数组的使用

异常语言：

1.数组索引越界异常：

           ArrayIndexQutOfBoundsException.

           eg.java.lang.ArrayIndexQutOfBoundsException.(目标数组不足以容纳源数组元素)

 2.调用可变参数时的异常：

             NullPointerException.（传递一个null值时）