四.数组
1.数组的概述
-
数组是相同类型数据的有序集合
-
数组描述的是相同的类型的若干个数据,按照一定的先后顺序排列组合而成。
-
其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问他们。
2.数组声明创建
package com.king.array;
public class Demo01 {
//数组的类型 变量的名字 =变量的值
//数组类型
public static void main(String[] args) {
//定义方式两种
int[] arr1;//1.定义 声明一个数组 首选
int arr2[];// 定义 次选
// 2. 通过new操作符来创建数组,语法如下
arr1=new int[10];// 这里可以存放10个 int类型的数字
// 3. 给数组元素赋值
arr1[0]=1;
arr1[1]=2;
arr1[2]=3;
arr1[3]=4;
arr1[4]=5;
arr1[5]=6;
arr1[6]=7;
arr1[7]=8;
arr1[8]=9;
//数组长度 用 arr1.length
// 如果 int类型的数组 未定义的 会默认赋值为0
// 例如 arr1[9]未赋值 输出 会默认为0
}
}
复制代码
- 常见错误 java.lang.ArrayIndexOutOfBoundsException:1 下标越界了 例如你数组只有5个元素 你访问到底6个了 这样就会报这个错
3.数组使用
数组的四个基本特点
- 其长度是固定的,数组一旦创建,它的大小是不可以改变的
- 其元素必须是相同的类型,不允许出向混合类型
- 数组中的元素可以是任意类型,包括基本类型和引用类型
- 数组变量属引用类型,数组也可以看成是对象,数组中的每个元素相当于该对象的变量成员。数组本身就是对象,Java中对象是在堆中的,因此数组类型无论是保存基本类型还是引用类型,数组对象本省是在堆中的。
package com.king.array;
public class Demo02 {
public static void main(String[] args) {
int[] arr={1,2,3,4,5};
// 计算所有元素的和
int sum=0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
System.out.println("sum="+sum);
//查找最大的元素
int max=arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i]>max){
max=arr[i];
}
}
System.out.println("max="+max);
}
}
复制代码
数组反转
public class Demo03 {
public static void main(String[] args) {
int[] arrs={1,2,3,4,5,6};
//forEach JDK1.5版本 没有下标
// for (int arr : arrs) {
// System.out.println(arr);
// }
int[] res=reverse(arrs);
for (int i = 0; i < res.length; i++) {
System.out.print(res[i]);
}
}
//反转数组
public static int[] reverse(int[] arrays){
//反转操作
int num1=arrays.length/2;
int[] dd=new int[arrays.length];
for (int i = 0; i <= num1; i++) {
dd[i]=arrays[arrays.length-i-1];
dd[arrays.length-i-1]=arrays[i];
}
return dd;
}
}
复制代码
4.多维数组
- 多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组。
- 二维数组
int a[][]=new int[2][5];
复制代码
- 解析:以上二维数组a可以看成一个两行五例的数组
package com.king.array;
public class Demo04 {
public static void main(String[] args) {
int[][] arr={{1,2},{3,4},{5,6}};
System.out.println(arr[0][0]);// 打印结果是 1
System.out.println(arr[1][1]); //打印结果是 4
}
}
复制代码
5.Arrays类
- 数组的工具类java.util.Arrays
- 由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays提供我们使用,从而可以对数据对象进行一些基本的操作
- Arrays类中的方法都是static修饰的静态方法,在使用的时候可以直接使用类名调用,而”不用“使用对象来调用(注意:是不用,而不是 不能)
- 具有以下常用功能:
- 给数组赋值:通过 fill 方法。
- 对数组排序:通过sort 方法,按升序
- 比较数组:通过equals 方法比较数组中元素值是否相等
- 查找数组元素:通过binarySearch 方法能对拍好序的数组进行二分查找法操作
package com.king.array;
import java.util.Arrays;
public class Demo05 {
public static void main(String[] args) {
int[] arr={1,3,4,5332,88,99,2403};
//打印数组元素Arrays.toString
System.out.println(Arrays.toString(arr));
printArry(arr);
}
//自己封装一下 但是不建议重复造轮子 只是为了了解原理 便于我们理解
public static void printArry(int[] args) {
for (int i = 0; i < args.length; i++) {
if(i==0){
System.out.print("[");
}
if (i==args.length-1){
System.out.print(args[i]+"]");
}else{
System.out.print(args[i]+", ");
}
}
}
}
复制代码
冒泡排序
- 冒泡排序无疑是最为出名的排序算法之一,总共有八大排序
public static void BubbleSort(int [] a, int n){
int j , k;
int flag = n ;//flag来记录最后交换的位置,也就是排序的尾边界
while (flag > 0){//flag>0的话说明排序未结束
k = flag; //k 来记录遍历的尾边界
flag = 0;
for(j=1; j<k; j++){
if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换
//交换a[j-1]和a[j]
int temp;
temp = a[j-1];
a[j-1] = a[j];
a[j]=temp;
//表示交换过数据;
flag = j;//记录最新的尾边界.
}
}
}
}
复制代码
6.稀疏数组
package com.king.array;
public class Demo06 {
public static void main(String[] args) {
//创建一个 9行 9列的二维数组
int[][] arr=new int[9][9];
arr[4][4]=1;
arr[5][6]=2;
//输出原始数组
System.out.println("输出原始的数组====");
for (int[] ints : arr) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println("");
}
//转换的稀疏数组
//获取有效值的个数
int sum=0;
for (int i = 0; i <arr.length ; i++) {
for (int j = 0; j < arr.length; j++) {
if (arr[i][j]!=0){
sum++;
}
}
}
System.out.println("============================");
System.out.println("有效值的个数"+sum);
// 2.创建一个稀疏数组的二维数组
int[][] arr2=new int[sum+1][3];
arr2[0][0]=9;
arr2[0][1]=9;
arr2[0][2]=sum;
//遍历二维数组,将非零的值,存放到稀疏数组里面
int count=0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
if(arr[i][j]!=0){
count++;
arr2[count][0]=i;
arr2[count][1]=j;
arr2[count][2]=arr[i][j];
}
}
}
System.out.println("稀疏数组");
for (int i = 0; i < arr2.length; i++) {
System.out.println(
arr2[i][0]+"\t"
+arr2[i][1]+"\t"
+arr2[i][2]);
}
System.out.println("=======================");
System.out.println("还原稀疏数组");
//1.读取稀疏数组
int[][] arr3=new int[arr2[0][0]][arr2[0][1]];
//2.给其中的元素还原它的值
for (int i = 1; i < arr2.length; i++) {
arr3[arr2[i][0]][arr2[i][1]]=arr2[i][2];
}
//3、打印
System.out.println("输出还原的的数组====");
for (int[] ints : arr3) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println("");
}
}
}
复制代码
近期评论