It's our wits that make us men.

Java学习笔记(6)数组

Posted on By Xc L


创建数组

数组是一个固定长度的,包含了相同类型数据的容器

声明数组

int[] a;声明了一个数组变量。 []表示该变量是一个数组 int表示数组里的每一个元素都是一个整数 a是变量名 但是,仅仅是这一句声明,不会创建数组

有时候也会写成int a[];没有任何区别

public class HelloWorld{
	public static void main(String[] args){
		//声明一个数组
		int[] a;
	}
}

创建数组

创建数组的时候,要指明数组的长度; new int[5]

引用的概念: 如果变量代表一个数组,比如a,我们把a叫做引用 与基本类型不同 int c = 5;这叫给c赋值为5

声明一个引用 int[] a; a = new int[5]; 让a这个引用,指向数组

public class HelloWorld{
	public static void main(String[] args){
		//声明一个引用
		int[] a;

		//创建一个长度是5的数组,并且使用引用a指向该数组
		a = new int[5];

		int[] b = new int[5];//声明的同时,指向一个数组
		
	}
}

访问数组

数组下标基0

下标0,代表数组里的第一个数

public class HelloWorld{
	public static void main(String[] args){
		int[] a;
		a = new int[5];

		a[0] = 1;//下标0,代表数组里的第一个数
		a[1]= 2;
        a[2]= 3;
        a[3]= 4;
        a[4]= 5;
	}
}

数组长度

.length属性用于访问一个数组的长度 数组访问下标范围是0到长度-1 一旦超过这个范围,就会产生数组下标越界异常

public class HelloWorld{
	public static void main(String[] args){
		int[] a;
		a = new int[5];//先声明一个引用,再把引用指向数组

		System.out.println(a.length);//打印数组的长度

		a[4] = 100;//下标4,实质上是“第五个”,即最后一个
		a[5] = 101;//下标5,实质上是”第六个“,超出范围,产生数组下标越界
		
	}
}

练习-数组最小值

首先创建一个长度是5的数组 然后给数组的每一位赋予随机整数 通过for循环,遍历数组,找出最小的一个值出来

0-100的随机整数的获取办法有多种,下面是参考办法之一

(int)(Math.random()*100)

Math.random()会得到一个0-1之间的随机浮点数,然后乘以100,并强转为整数即可。

public class HelloWorld{
	public static void main(String[] args){
		int[] a = new int[5];
		a[0] = (int)(Math.random()*100);
		a[1] = (int)(Math.random()*100);
		a[2] = (int)(Math.random()*100);
		a[3] = (int)(Math.random()*100);
		a[4] = (int)(Math.random()*100);
		int Minmum = 0;

		for(int i = 0;i<a.length;i++)
			System.out.println("数组中的各个随机数是:"+a[i]);
			if(Maxnum>a[i]){
				Minmum = i;
			}	
		System.out.println("本练习的目的是,找出最小的一个值"+Minmum);
	}
}

Java如何初始化数组

分配空间与赋值分步进行

分配空间与赋值分步进行

public class HelloWorld{
	public static void main(String[] args){
		int[] a = new int[5];//分配了长度是5的数组,但没有赋值

		//没有赋值,那么就会使用默认值
		//作为int类型的数组,默认值是0
		System.out.println(a[0]);

		//进行赋值

		a[0] = 100;
		a[1] = 101;
		a[2] = 103;
		a[3] = 120;
		a[4] = 140;
	}
}

分配空间,同时赋值

分配空间,同时赋值

public class HelloWorld{
	public static void main(String[] args){
		//写法一:分配空间的同时赋值
		int[] a = new int[]{100,102,444,834,3212};

		//写法二:省略了 new int[] ,效果一样
		int[] b = {100,102,444,834,3212};

		//写法三:同时分配空间,和指定内容
		//在这个例子里,长度是3,内容是5个,产生矛盾了
		//所以如果指定了数组的内容,就不能同时设置数组的长度
		int[] c = new int[3]{100,102,444,834,3212};
	}
}

练习-数组反转

首先创建一个长度是5的数组,并填充随机数。

使用for循环或者while循环,对这个数组实现反转

答案:

public class HelloWorld{
	public static void main(String[] args){
		int[] a = new int[];
		a[0] = (int)(Math.random()*100);
		a[1] = (int)(Math.random()*100);
		a[2] = (int)(Math.random()*100);
		a[3] = (int)(Math.random()*100);
		a[4] = (int)(Math.random()*100);

		for(int i = 0;i<a.length;i++){
			System.out.println(a[i]+" ");
		}
		System.out.println();
		//使用临时数组
		int temp[] = new int[a.length];
		for(int i = 0;i<temp.length;i++){
			temp[i] = a[temp.length-i-1];
		}

		for(int i = 0;i<temp.length;i++){
			System.out.println(temp[i]+" ");
		}
		System.out.println();

		//再顺着放回去
		for(int i = 0;i<temp.length;i++){
			a[i] = temp[i];
		}

		for(int i = 0;i<a.length;i++){
			System.out.println(a[i]+" ");
		}
		System.out.println();
	}
}

答案:方法二:

public class HelloWorld{
	public static void main(String[] args){
		int[] a = new int[];
		a[0] = (int)(Math.random()*100);
		a[1] = (int)(Math.random()*100);
		a[2] = (int)(Math.random()*100);
		a[3] = (int)(Math.random()*100);
		a[4] = (int)(Math.random()*100);
		//打印原数组
		for(int i = 0;i<a.length;i++){
			System.out.println(a[i]+" ");
		}
		System.out.println();

		//方法二:首位交换
		for(int i = 0;i<a.length/2 ;i++){
			int temp = a[a.length-i-1];
			a[a.length-i-1] = a[i];
			a[i] = temp;	
		}

		for(int i = 0;i<a.length;i++){
			System.out.println(a[i]+" ");
		}
		System.out.println();
						
	}
}

Java数组选择法,冒泡排序

选择法排序

选择法排序的思路

把第一位和其他所有的进行比较,只要比第一位小的,就换到第一个位置来 比较完之后,第一位就是最小的 然后再从第二位和剩余的其他所有进行比较,只要比第二位小的,就换到第二个位置来 比较完之后,第二位就是第二小的

以此类推

public class HelloWorld{
	public static void main(String[] args){
		int[] a = new int[]{18,62,68,82,65,9};
		//排序前先把内容打印出来
		for(int i = 0;i<a.length;i++){
			System.out.println(a[i]+" ");
		}
		System.out.println("\n");
		//选择排序法

		//第一步:先把第一位和其他所有位进行比较
		//如果发现其他所有位置的数据比第一位小,就进行交换

		for(int i = 1;i<a.length;i++){
			if(a[i]<a[0]){
				int temp = a[0];
				a[0] = a[i];
				a[i] = temp;
			}
		}
		//把内容打印出来
		//可以发现,最小的一个数,到了最前面
		for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println("\n");

        //第二步:把第二位的和剩下的所有位进行比较
        for(int i = 2;i<a.length;i++){
			if(a[i]<a[1]){
				int temp = a[1];
				a[1] = a[i];
				a[i] = temp;
			}
        }
        //把内容打印出来
        //可以发现,倒数第二小的数,到了第二个位置
        for(int i = 0;i<a.length;i++){
			System.out.println(a[i]+" ");
        }
        System.out.println("\n");

        //可以发现一个规律
        //移动的位置是从0逐渐增加的
        //所以可以在外面套一层循环

        for(int j = 0;j<a.length-1;i++){
			for(int i = j+1;i<a.length;i++){
				if(a[i]<a[j]){
					int temp = a[j];
					a[j] = a[i];
					a[i] = temp;
				}
			}
        }

        //把内容打印出来
        for(int i = 0;i<a.length;i++){
			System.out.println(a[i]+" ");
        }
        System.out.println("\n");
	}
}

冒泡法排序

冒泡法排序的思路: 第一步:从开始,把相邻的两位进行比较 如果发现后面的比前面的大,就把大的数据交换在后面,循环比较完毕后,最后一位就是最大的 第二步:再来一次,只不过不用比较最后一位 以此类推

public class HelloWorld{
	public static void main(String[] args){
		int[] a = new int[]{18,62,68,65,9};
		//排序前,先把内容打印出来
		for(int i =0;i<a.length;i++){
			System.out.println(a[i]+" ");
		}
		System.out.println("\n");
		//冒泡法排序

		//第一步:从第一位开始,把相邻的两位进行比较
		//如果发现前面的比后面的大,就把大的数据交换在后面

		for(int i = 0;i<a.length;i++){
			if(a[i]>a[i+1]){
				int temp = a[i];
				a[i] = a[i+1];
				a[i+1] = temp;
			}
		}
		//把内容打印出来
		//可以发现,最大的到了最后面
		for(int i = 0;i<a.length;i++){
			System.out.println(a[i]+" ");
		}
		System.out.println("\n");

		//第二步:再来以此,只不过不用比较最后一位
		for(int i = 0;i<a.length-2;i++){
			if(a[i]>a[i+1]){
				int temp = a[i];
				a[i] = a[i+1];
				a[i+1] = temp;
			}
		}
		//把内容打印出来
		//可以发现,倒数第二大的到了导数第二个位置
		for(int i = 0;i<a.length;i++){
			System.out.println(a[i]+" ");
		}
		System.out.println("\n");

		//可以发现一个规律
		//后边界在收缩
		//所以可以在外面套一层循环

		for(int j = 0;j<a.length;j++){
			for(int i = 0;i<a.length-j-1;i++){
				if(a[i]>a[i+1]){
					int temp = a[i];
					a[i] = a[i+1];
					a[i+1] = temp;
				}
			}
		}

		//把内容打印出来
		for(int i = 0;i<a.length;i++){
			System.out.println(a[i]+" ");
		}
		System.out.println("\n");
	}
}

练习-排序

首先创建一个长度是5的数组,并填充随机数。

首先用选择法正排序,然后再对其使用冒泡法倒排序

注 所谓的正排序就是从小到大排序,倒排序就是从大到小排序

答案:

public class HelloWorld {
    public static void main(String[] args) {
        int[] a = new int[5];
        for (int i = 0; i < a.length; i++) {
            a[i] = (int) (Math.random() * 100);
            System.out.print(a[i] + " ");
        }
        System.out.println("\n");
        // 选择排序法
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = i + 1; j < a.length; j++) {
                int temp = a[i];
                if (a[i] > a[j]) {
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
        System.out.println("正排序數組:");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        // 冒泡排序法
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                int temp = a[j];
                if (a[j] < a[j + 1]) {
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                }
            }
        }
        System.out.println("\n倒排序數組:");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
}

Java中如何使用增强for循环

增强型for循环在遍历一个数组的时候会更加快捷

增强型for循环

注:增强型for循环只能用来取值,却不能用来修改

public class HelloWorld{
	public static void main(String[] args){
		int values [] = new int[]{18,62,68,82,65,9};
		//常规遍历
		for(int i = 0;i<values.length;i++){
			int each = values[i];
			System.out.println(each);
		}

		//增强型for循环遍历
		for(int each:values){
			System.out.println(each);
		}
	}
}

练习-最大值

用增强for循环找出最大值

答案:

public class HelloWorld{
	public static void main(String[] args){
		int a [] = new int[]{18,62,68,82,65,9};
		//打印所有值
		for(int i = 0;i<a.length;i++){
			System.out.println(a[i]+" ");
		}
		for(int j:a){
			if(j>Maxnum){
				Maxnum = j;
			}
		}
		System.out.println("最大数值为:"+Maxnum);
	}
}

Java如何复制数组

数组的长度是不可变的,一旦分配好空间,是多长,就多长,不能增加也不能减少

复制数组

把一个数组的值,复制到另一个数组中

System.arraycopy(src,srcPos,dest,destPos,length)

src:源数组

srcPos:从源数组复制数据的起始位置

dest:目标数组

dastPos:复制目标数组的起始位置

length:复制的长度

public class HelloWorld{
	public static void main(String[] args){
		int a [] = new int[]{18,62,68,82,65,9};

		int b [] = new int[3];//分配了长度是3的空间,但是没有赋值

		//通过数组赋值,把a数组的前3位赋值到b数组

		//方法一:for循环

		for(int i = 0; i<b.length;i++){
			b[i] = a[i];
		}

		//方法二:System.arraycopy(src,srcPos,dest,destPos,length)
		//src: 源数组
        //srcPos: 从源数组复制数据的启始位置
        //dest: 目标数组
        //destPos: 复制到目标数组的启始位置
        //length: 复制的长度 
        System.arraycopy(a,0,b,0,3);

        //把内容打印出来
        for(int i = 0; i<b.length;i++){
			System.out.println(b[i]+" ");
        }
	}
}

练习-合并数组

首先准备两个数组,他俩的长度是5-10之间的随机数,并使用随机数初始化这两个数组

然后准备第三个数组,第三个数组的长度是前两个的和 通过System.arraycopy把前两个数组合并到第三个数组中

答案:

import java.util.Arrays;
import java.util.Random;

public class HelloWorld{
	public static void main(String[] args){
		int a[] = new int[(int)(Math.random()*5)+5];
		int b[] = new int[(int)(Math.random()*5)+5];
		for(int i = 0;i<a.length;i++){
			a[i] = (int)(Math.random()*100);
		}
		for(int i = 0;i<b.length;i++){
			b[i] = (int)(Math.random()*100);
		}
		//打印数组a的内容
		for(int i : a){
			System.out.println(a[i]+" ");
		}
		//打印数组b的内容
		for(int i : b){
			System.out.println(b[i]+" ");
		}

		int [] c = new int[a.length+b.length];
		System.arraycopy(a,0,c,0,a.length);
		System.arraycopy(b,0,c,a.length,b.length);
		for(int temp : c){
			System.out.println(c[temp]+" ");
		}
	}
}

Java如何使用二维数组

这是一个一维数组,里面的每一个元素,都是一个基本类型int

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

这是一个二维数组,里面的每一个元素都是一个一维数组

所以二维数组又叫数组的数组

int b[][] = new int[][]{
	{1,2,3},
	{4,5,6},
	{7,8,9}
};

初始化二维数组

public class HelloWorld{
	public static void main(String[] args){
		//初始化二维数组
		int[][] a = new int[2][3];//有两个一维数组,每一个一维数组的长度是3
		a[1][2] = 5;//可以直接访问一维数组,因为已经分配了空间

		//只分配了二维数组
		int[][] b = new int[2][];//有两个一维数组,每一个一维数组的长度暂未分配
		b[0] = new int[3];//必须事先分配长度,才可以访问
		b[0][2] = 5;

		//指定内容的同时,分配空间
		int[][] c = new int[][]{
			{1,2,4},
			{4,5},
			{6,7,8,9}
		};
	}
}

练习-二维数组

定义一个5x5的二位数组。然后使用随机数填充该二维数组。 找出这个二维数组里,最大的那个值,并打印其二维坐标

0-100的随机整数的获取办法有多种,下面是参考办法之一

(int)(Math.random()*100)

Math.random()会得到一个0-1之间的随机浮点数,然后乘以100,并强制转为整型即可。

答案:

import java.util.Random;

public class HelloWorld{
	public static void main(String[] args){
		int [][] a = new int[5][5];
		int max = 0;
		int x = 0;
		int y = 0;
		for(int i = 0;i<a.length;j++)
		{
			for(int j = 0;j<a[i].length;j++)
			{
				a[i][j] = (int)(Math.Random()*100);
				System.out.println(a[i][j]+"\t");
				if(a[i][j]>=max){
					max = a[i][j];
					x = i;
					y = j;
				}
			}
			System.out.println();
		}
		System.out.println("-----二维数组的foreach语句同义表达-----");
		for(int[] i:a)    //二维数组的foreach语句的同义表达式
		{
			for(int j:i)
			{
				System.out.println(j+"\t");
			}
			System.out.println();
		}
		System.out.println("找出最大值是:"+max);
		System.out.println("坐标是:["+(x+1)"]["+(y+1)+"]")
	}
}

JAVA.UTIL.ARRAYS类常用方法

Arrays是针对数组的工具类,可以进行排序,查找,复制填充等功能。大大提高了开发人员的工作效率。

关键字 简介
copyOfRange 数组复制
toString() 转换为字符串
sort 排序
binarySearch 搜索
equals 判断是否相同
fill 填充

复制数组

与使用System.arraycopy进行数组复制类似的,Arrays提供了一个copyOfRange方法进行数组复制。

不同的是System.arraycopy,需要事先准备好目标数组,并分配长度。copyOfRange只需要源数组就可以了,通过返回值,就能够得到目标数组了。

除此之外,需要注意的是copyOfRange的第3个参数,表示源数组的结束位置,是取不到的。

import java.util.Arrays;

public class HelloWorld{
	public static void main(String[] args){
		int a[] = new int[]{18, 62, 68, 82, 65, 9};

		//copyOfRange(int[] original, int from, int to)
		//第一个参数表示源数组
		//第二个参数表示开始的位置(取得到)
		//第三个参数表示结束位置(取不到)
		int[] b = Arrays.copyOfRange(a,0,3);

		for (int i = 0; i < b.length; i++) {
            System.out.print(b[i] + " ");
        }
		
	}
}

转换为字符串

如果要打印一个数组的内容,就需要通过for循环来挨个遍历,逐一打印

但是Arrays提供了一个toString()方法,直接把一个数组,转换为字符串,这样方便观察数组的内容

import java.util.Arrays;

public class HelloWorld{
	public static void main(String[] args){
		int a[] = new int[] { 18, 62, 68, 82, 65, 9 };
		String content = Arrays.toString(a);
		System.out.println(content);
	}
}

排序

在前面的章节学习了选择排序法和冒泡排序法,Arrays工具类提供了一个sort方法,只需要一行代码即可完成排序功能。

import java.util.Arrays;

public class HelloWorld{
	public static void main(String[] args){
		int a[] = new int[]{18,62,68,82,65,9};
		System.out.println("排序之前:");
		System.out.println(Arrays.toString(a));
		Arrays.sort(a);
		System.out.println("排序之后:");
		System.out.println(Arrays.toString(a));
	}
}

搜索

查询元素出现的位置

需要注意的是,使用binarySearch进行查找之前,必须使用sort进行排序

如果数组中有多个相同的元素,查找的结果是不确定的。

import java.util.Arrays;

public class HelloWorld{
	public static void main(String[] args){
		int a[] = new int[]{18,62,68,82,65,9};

		Arrays.sort(a);

		System.out.println(Arrays.toString(a));
		//使用binarySearch之前,必须先使用sort进行排序
		System.out.println("数字62出现的位置:"+Arrays.binarySearch(a,62));
	}
}

填充

使用同一个值,填充整个数组

import java.util.Arrays;


public class HelloWorld{
	public static void main{
		int a[] = new int[10];

		Arrays.fill(a,5);

		System.out.println(Arrays.toString(a));
	}
}

练习-二维数组排序

首先定义一个5x8 的二维数数组,然后使用随机数填充满。 借助Arrays的方法对二维数组进行排序。

参考思路 先把二维数组使用System.arraycopy进行数组复制到一个一维数组 然后使用sort进行排序 最后再复制回到二维数组。

import java.util.Arrays;

public class HelloWorld{
	public static void main(String[] args){
		int[][] a = new int[5][8];
		for (int i = 0; i < 5; i++) {
            System.out.println("arr["+i+"]:");
            for(int j = 0; j < 8; j++) {
                a[i][j] = (int)(Math.random()*100);
                System.out.println("\t"+a[i][j]);
            }
        }
 		for(int[] each:a){
			Arrays.sort(each);
 		}

 		System.out.println("---------sorted--------");

 		for(int i = 0;i<5;i++){
			System.out.println("arr["+i+"]:");
			for(int j = 0;j<8;j++){
				//a[i][j] = (int)(Math.random()*100);
				System.out.println("\t"+a[i][j]);
			}
 		}
	}
}