数组（array）数组就是多个相同类型数据的组合，实现对这些数据的统一管理。 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。数组属引用类型，数组型数据是对象（object），
数组的分类：
一维数组、二维数组、三维数组...多维数组：从二维开始都算多维数组，一般到二维就差不多了。
二维数组又称为矩阵。
先把一行看成一个整体的话，二维数组就是一个“特殊一维数组”
二维数组的行数，就是“特殊一维数组”的长度，二维数组名.length；
一行同时又是一个一维数组，一行的列数，行.length；
行：就是“特殊一维数组”的一个元素，二维数组名[下标]
二维数组的相关表示方式：
行：二维数组名[行下标] 行下标的范围[0, 总行数-1]
元素：二维数组名[行下标][列下标] 列下标的范围[0, 该行的总元素的个数-1]
行数：二维数组名.length
每一行的列数：二维数组名[行下标].length
二维数组如何声明？
元素的数据类型[][] 二维数组名;
例如：要存储每一组的学员的成绩，构成全班的成绩数组。
二维数组的初始化？
1、静态初始化
二维数组名 = new 元素的数据类型[][]{{第一行的元素列表},{第二行的元素列表}....};
声明 静态初始化：元素的数据类型[][] 二维数组名 = {{第一行的元素列表},{第二行的元素列表}....};
int[][] scores2; //1. 先声明
scores2 = new int[][]{{1,2,3},{3,4,5},{6}}; //2.静态初始化
2、动态初始化
一维数组的动态初始化： 一维数组名 = new 元素的数据类型[长度];
二维数组的动态初始化：
1、每一行的列数是相同的，规则的矩阵
二维数组名 = new 元素的数据类型[行数][列数];
2、每一行的列数是不相同的，不规则的矩阵
（1）第一步先确定总行数
二维数组名 = new 元素的数据类型[行数][];
（2）依次确定每一行的列数
行 = new 元素的数据类型[列数];
for(int i = 0; i < arr.length; i ){ //确定每行的列数； --->> 为元素赋值 --->> 遍历显示 --->>换行
arr[i] = new int[i 1];
}
String[][] names; //1.二维数组的声明
//names = new String[6][5];//动态初始化的方式一
names = new String[6][0]; //动态初始化的方式二,先确定行数；再确定列数。
names[0] = new String[5];
names[1] = new String[3];
names[2] = new String[7];
names[3] = new String[9];
names[4] = new String[2];
names[5] = new String[4];
二维数组如何为元素赋值
二维数组名 [行下标][列下标] = 值；
二维数组的遍历
for(int i=0; i<行数; i ){
for(int j=0; j<每一行的列数; j ){
元素：二维数组名[行下标][列下标]，即二维数组名[i][j]
}
}
数组的遍历/赋值 最高分和最低分 数组的反转 class ShuZu{
public static void main(String[] args){
java.util.Scanner input = new java.util.Scanner(System.in);
//输入小组人数
System.out.print("请输入小组人数:");
int count = input.nextInt();
//声明和初始化name和score数组
String[] name; //先声明
name = new String [count]; //动态初始化
int[] score = new int[count]; //声明 动态初始化
//遍历数组赋值
for (int i = 0; i < name.length; i ){
System.out.print("第" (i 1) "个同学的名字:");
name[i] = input.next();
System.out.print("第" (i 1) "个同学的成绩:");
score[i] = input.nextInt();
}
//遍历数组
System.out.println("学生姓名和成绩如下:");
for (int i = 0;i < name.length;i ){
System.out.print(name[i] ":");
System.out.print(score[i] "分" "\n");
}
//对数组score进行遍历找出最高分和最低分
int max = score[0];
int min = score[0];
int indexMax = 0;//
int indexMin = 0;
int sum = 0;
for(int i = 0; i < score.length; i ){ //也可以i < count;
sum = score[i];
if(max < score[i]){
max = score[i];
indexMax = i;
}if(min > score[i] ){
min = score[i];
indexMin = i;
}
}System.out.println("第" (indexMax 1) "个同学" name[indexMax] "的成绩是最高的为:" max);
System.out.println("第" (indexMin 1) "个同学" name[indexMin] "的成绩是最高的为:" min);
System.out.println("总分为:" sum "平均分是:" sum/count);
//数组的反转(首尾对应位置交换,借助第三个变量)
for(int i = 0;i <= score.length/2; i ){
int temp = score[i];
score[i] = score[score.length-1-i]; //[1,2,3,4,5,6] 1(0)和6(5)；2(1)和5(4)...
score[score.length-1-i] = temp;
}
for(int i = 0; i< score.length;i ){
System.out.print(score[i] "\t");
}
//数组的反转,方法二:借助一个空(新)数组
int[] temp = new int[count];
for(int i = 0;i < score.length;i ){
temp[i]=score[score.length-1-i];
}
score = temp; //废弃旧数组，指向新数组
for(int i = 0;i < score.length;i ){
System.out.print(score[i] "\t");
}
}
}
由基本数据类型创建的数组它的默认值： public class TestArray0 {
public static void main(String[] args){
//对于基于基本数据类型的变量创建的数组:byte short int long float double char boolean
//1.对于byte short int long而已：创建数组以后，默认值为0
int[] scores = new int[4];
scores[0] = 89;
scores[3] = 90;
for(int i = 0;i < scores.length;i ){
System.out.println(scores[i]);
}
//2.对于float double而言；默认值是0.0
float[] f = new float[3];
f[0] = 1.2F;
for(int i = 0; i < f.length;i ){
System.out.println(f[i]);
}
System.out.println();
//3.对于char而言，默认是空格
char[] c = new char[3];
for(int i = 0; i < c.length;i ){
System.out.println(c[i]);
}
System.out.println();
//4.对于boolean而言，默认是false
boolean[] b = new boolean[3];
for(int i = 0; i < b.length;i ){
System.out.println(b[i]);
}
System.out.println();
//5.对于引用类型的变量构成的数组而言：默认初始化值为null。以String为例
String[] strs = new String[4];
strs[0] = "AA";
strs[1] = "BB";
//strs[2] = "CC"; 默认为null
strs[3] = "DD";
//遍历数组的元素
for (int i = 0;i < strs.length;i ){
System.out.println(strs[i]);
}
//自定义的类
System.out.println();
Person[] pers = new Person[3];
for(int i = 0; i < pers.length;i ){
System.out.println(pers[i]);
}
}
}
class Person{
}
数组在内存中的结构
整个内存里边的基本结构就分这4部分：
new出来数组、对象； 方法区：类名、包名、方法的定义等；常量池、字符串常量池等，想用哪个从池子里边拿 静态区：静态的变量，用static修饰的变量等。 以数组为例，看它如何使用内存结构的： java虚拟机进行解释运行对它进行初始化，栈先进后出，scores变量先存放在栈里边，每个内存里边都对应一个地址；new出来的放在堆里边。通过地址进行对应
public class TestArray {
public static void main(String[] args){
//1.如何定义一个数组
//1.1数组的声明
String[] names;
int scores[];
//1.2初始化
//第一种：静态初始化：初始化数组与给数组赋值同时进行。
names = new String[]{"kris","alex","egon"};
//第二种：动态初始化：初始化数组与给数组元素赋值分开进行。
scores = new int[4];
//2.如何调用相应的数组元素:通过数组元素的下角标的方式来调用。
//下角标从0开始，到n-1结束，其中n表示数组的长度。
scores[0] = 87;
scores[1] = 88;
scores[3] = 90;
//3.数组的长度：通过数组的length属性。
System.out.println(names.length);//3
System.out.println(scores.length); //4
//4.如何遍历数组元素
// System.out.println(names[0]);
// System.out.println(names[1]);
// System.out.println(names[2]);
for (int i = 0; i < names.length; i ){
System.out.println(names[i]);
}
}
}
//数组一旦初始化，其长度是不可变的
public class TestAarry1 {
public static void main(String[] args){
int[] i = new int[]{12,13,14};
int[] j = new int[10];
for(int k = 0;k < i.length;k ){
j[k] = i[k];
}
j[3] = 15;
j[4] = 16;
for(int k = 0; k < j.length;k ){
System.out.println(j[k]);
}
}
}
package com.du.bai.www;
public class TestArry2 {
public static void main(String[] args){
int[] scores1 = new int[10];
int[][] scores2;
String[][] names;
//1.二维数组的初始化
scores2 = new int[][]{{1,2,3},{3,4,5},{6}}; //静态初始化
names = new String[6][5];//动态初始化的方式一
names = new String[6][0]; //动态初始化的方式二
names[0] = new String[5];
names[1] = new String[3];
names[2] = new String[7];
names[3] = new String[9];
names[4] = new String[2];
names[5] = new String[4];
//错误的初始化方式
//names = new String[][];
//names = new String[][5];
//2.如何来引用具体的某一个元素
int[][] i = new int[3][2]; //int[] i[] = new int[3][2];
i[1][0] = 90;
i[2][1] = 89;
//3.数组的长度
//二维数组的长度;length属性
System.out.println(i.length); //3
//二维数组中元素的长度
System.out.println(i[0].length); //2
System.out.println(names.length); //6
System.out.println(names[4].length); //8
System.out.println();
//4.如何遍历二维数组
for(int m = 0; m < scores2.length;m ){ //控制行数
for(int n = 0;n < scores2[m].length;n ){
System.out.print(scores2[m][n] " ");
}
System.out.println();
}
}
}
异常： public class TestException {
public static void main(String[] args){
//1.数组下标越界异常：java.lang.ArrayIndexOutOfBoundsException
int[] i = new int[10];
//i[0] = 90;
//i[10] = 99;
// for (int m = 0;m <= i.length;m ){
// System.out.println(i[m]);
// }
//2.空指针的异常：NullPointerException
//第一种：
// boolean[] b = new boolean[3];
// b = null;
// System.out.println(b[0]);
//第二种：
// String[] str = new String[4];
// str[3] = new String("AA"); //str[3] = "AA";
// System.out.println(str[3].toString());
//第三种：
int[][] j = new int[3][];
j[2][0] = 12;
}
}
public class TestGetSum {
public static void main(String[] args){
int[][] m = new int[][]{{3,8,2},{2,7},{9,0,1,6}};
int sum = 0;
for (int i = 0;i < m.length;i ){
for(int j = 0;j < m[i].length;j ){
System.out.print(m[i][j] "\t");
sum = m[i][j];
}
System.out.println();
}
System.out.println("总和为:" sum);
}
}
public class TestYangHui {
public static void main(String[] args){
int[][] yangHui = new int[10][];
//1.初始化二维数组
for(int i = 0;i < yangHui.length;i ){
yangHui[i] = new int[i 1];
}
//2.显示的为二维数组的每个元素赋值
for(int i = 0;i < yangHui.length;i ){
for(int j = 0;j < yangHui[i].length;j ){
yangHui[i][0] = yangHui[i][i] = 1;
if (i > 1 && j > 0 && j < i){
yangHui[i][j] = yangHui[i - 1][j] yangHui[i - 1][j - 1];
}
}
}
//遍历二维数组
for(int i = 0;i < yangHui.length;i ){
for(int j = 0; j < yangHui[i].length;j ){
System.out.print(yangHui[i][j] "\t");
}
System.out.println();
}
}
}
class Test{
public static void main(String[] args){
int[] array1, array2;
array1 = new int[]{2,3,5,7,11,13,17,19};
//遍历array1
for(int i = 0; i < array1.length;i ){
System.out.println(array1[i] "\t");
}
System.out.println();
array2 = array1; //这样子赋值，修改array2的内容，array1也会改变。
//修改array2
for (int i = 0;i < array2.length;i ){
if(i % 2 == 0){
array2[i] = i;
}
}
//遍历array1
for(int i = 0;i < array1.length;i ){
System.out.print(array1[i] "\t");
}
}
}
API，数组工具类API：应用程序编程接口，俗称“帮助文档”
java.util.Arrays：数组工具类
此类包含用来操作数组（比如排序和搜索）的各种方法。
（1）int binarySearch(int[] a, int key)
a - 要搜索的数组
key - 要搜索的值
结果：如果它(key)包含在数组(a)中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
插入点：被定义为将键(key)插入数组(a)的那一点
二分查找的前提：数组必须是有序的
（2）void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。
（3）int[] copyOf(int[] original, int newLength)
复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。
original - 要复制的数组，源数组
newLength - 要返回的副本的长度
结果：原数组的副本，截取或用 0 填充以获得指定的长度
（4）int[] copyOfRange(int[] original, int from, int to)
original - 将要从其复制一个范围的数组，源数组
from - 要复制的范围的初始索引（包括）
to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。
结果：original数组的[from,to)
（5） void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组的每个元素。
a - 要填充的数组
val - 要存储在数组所有元素中的值
（6）String toString(int[] a)
返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成，括在方括号（"[]"）中。
相邻元素用字符 ", "（逗号加空格）分隔。
a - 返回其字符串表示形式的数组
结果：a 的字符串表示形式，是一个字符串
....
class TestApi{
public static void main(String[] args){
//java.util.Scanner
//1.找下标
int[] arr = {8,2,0,4,5,1,6,9,3};
int find = 5;
int index = java.util.Arrays.binarySearch(arr,find);
//因为这个工具的binarySearch方法会返回一个结果，所以我要用一个变量接收这个结果
System.out.println("index=" index);
//2.排序，从小到大
java.util.Arrays.sort(arr);
for(int i = 0;i < arr.length; i ){
System.out.print(arr[i] "\t");
}
//3.复制一个和原来长度一模一样的数组,两倍长就是arr.length * 2
//int[] xin = java.util.Arrays.copyOf(arr, arr.length);
//复制数组前3个；
//int[] xin = java.util.Arrays.copyOf(arr, 3);
//要复制arr数组，但是我想要从arr[2]复制到arr[5],
//int[] xin = java.util.Arrays.copyOfRange(arr,3,5 1);
//要复制arr数组，但是我想要从arr[2]开始到最后，并且新数组的长度是10
//假设原数组够长，新数组的长度要10，从[2]~[11]，但是11不包含，所以写12
//int[] xin = java.util.Arrays.copyOfRange(arr, 2, 12);
//4.填充
int[] arr1 = new int[10];//用3填充数组arr
//java.util.Arrays.fill(arr1, 3);
java.util.Arrays.fill(arr1, (int)(Math.random()*100));
for(int num : arr1){
System.out.print(num "\t");
}
String str = java.util.Arrays.toString(arr);
System.out.println(str);
}
}
来源：http://www./content-1-84051.html |
|
|
