Java基础复习—数组
文章目录
- 前言
- 数组的定义
- 数组的初始化
- 静态初始化：
- 动态初始化：
- 数组的访问
- 获取数组的长度
- 通过访问下标访问数组元素(数组元素位置交换)
- 数组的逆序输出
- [案例] 利用数组累加分数成绩
- 数组的复制
- 数组的扩容
- 二维数组的定义与初始化
- 数组排序问题的研究
- 冒泡排序
- 插入排序
- Arrays.sort排序(高效排序法)
前言
计算机程序离不开算法和数据结构。
数据结构就是把数据按照某种特定的结构来保存。
数组是编程语言中最常见的一种数据结构，可以用于存储多个数据，每个数组元素存放一个数据。
通常，可以通过数组元素的索引来访问数组元素，包括为数组元素赋值和取出数组元的值。
Java的数组要求所有的数组元素具有相同的数据类型。因此，在一个数组中，数组元素的类型是唯一的(即一个数组里只能存放一种数据类型的数据)。
数组也是一种数据类型，它本身是一种引用类型。
例如： int 是一个基本类型，但 int[ ] (定义数组的一种方式) 就是一种引用类型。
数组的定义
Java语言支持两种语法格式来定义数组
语法：
int[ ] arrayName(推荐); 具有更好的可读性
int arrayName[ ] (不推荐); 可读性差
以上的数组还不能使用，只有对数组进行初始化才能使用。
数组的初始化
数组的初始化: 就是对数组的数组元素分配内存空间，并为每个数组元素赋初始值。
静态初始化：
初始化时由程序员显式指定每个数组元素的初始值，由系统决定数组长度，语法格式如下：
type0 arrayName = new type[]{element1,element2,element3,....}
解析：type 是数据元素的数据类型，此处的 type 必须与定义数组变量( arrayName )时所用的 type0 相同，也可以是定义数组时所指定的 type0 的子类。
静态初始化语法格式如下：
type[] arrayName = {element1,element2,element3,....};
例如，如下代码：
Object类是所有类的父类，包括我们所写的类，我们在使用类的时候就会利用Object类中的方法~
package day01;
public class Type {
public static void main(String[] args) {
//定义一个 int 数组类型的变量
int [] Intarr;
//使用静态初始化,初始化数组时只指定数组元素的初始值,不指定数组长度
Intarr = new int[] {5,6,7,8,9};
//定义一个Object数组类型的变量
//String 是 Object 的子类,字符串String是一种特殊的Object实例
//使用静态初始化,初始化数组时数组元素的类型是定义数组时数组元素类型的子类
Object [] objecarr;
objecarr = new String [] {"javaWeb","张三"};
//使用静态初始化
Object [] objecarr2;
objecarr2 = new Object [] {"java","张三"};
System.out.println(objecarr[0]);
//静态初始化简化格式
String[] arrayName = {"java","张三","zbt"};
System.out.println(arrayName[2]);
//以","为分隔符,将字符串拆分为字符数组
String ss = "java,zbt,张三";
String[] s1 = ss.split(",");
for(int i=0;i<=ss.length();i++) {
System.out.println(s1[i]+" ");
}
}
}
动态初始化：
初始化只指定数组的长度，由系统为每个数组元素指定初始值. 语法格式如下：
type0[] arrayName = new type[length];
动态初始化的用法，代码如下：
package day01;
public class Type {
public static void main(String[] args) {
//定义一个存放分数的数组
//动态初始化数组,指定数组长度
int[] score = new int[3];
score[0] = 10;
score[1] = 20;
score[2] = 30;
//循环输出score[]
for(int i=0;i<score.length;i++)
System.out.println(score[i]);
}
}
//输出结果：10 20 30
//错误示例
package day01;
public class Type {
public static void main(String[] args) {
//定义一个存放分数的数组
//动态初始化数组,指定数组长度
int[] score = new int[3];
//静态初始化数组,这时动态初始化的长度失效,无意义
score = new int[]{10,20,30,40};
for(int i=0;i<score.length;i++)
System.out.println(score[i]);
}
}
//输出结果：10 20 30 40
数组的访问
数组初始化完成后，可以使用数组，包括数组元素，访问数组元素和获得数组长度
获取数组的长度
代码如下：
package day01;
public class Type {
public static void main(String[] args) {
int[] arr = {10,20,30,40};
//通过length获取
int len = arr.length;
System.out.println(len);
}
}
//运算结果：4
通过访问下标访问数组元素(数组元素位置交换)
Java 数组的下标是从数组元素 0 开始,下标为 0
代码如下(临时变量法)：
package day01;
public class Type {
public static void main(String[] args) {
int[] arr = {10,20,30,40};
//交换数组第2个元素和第3个元素
int temp = arr[2];
arr[2] = arr[3];
arr[3] = temp;
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
//运算结果为： 10 20 40 30
数组的逆序输出
package day01;
public class Type {
public static void main(String[] args) {
//创建数组
int[] arr = {10,20,30,40,50};
//在逆序输出时,第一个访问原始的下标从数组的长度减一开始
//然后不断递减,直到i=0
//arr.length = 5
//数组从下标[0]开始算起
for(int i=arr.length-1;i>=0;i--) {
System.out.println(arr[i]);
}
}
}
[案例] 利用数组累加分数成绩
在访问数组元素时，一定要注意下标不能大于或等于数组的长度，否则会报 数组下标越界异常 [ArrayIndexOutOfBoundsException ]
package day01;
import java.util.Scanner;
public class Type {
public static void main(String[] args) {
Scanner sca = new Scanner(System.in);
//定义一个存放分数的数组
//动态初始化数组,只指定数组长度
int[] score = new int[5];
//课程名称
String[] names = {"Core Java","Oracle","JSP","C","Office"};
//循环对score数组进行初始化
for(int i=0;i<names.length;i++) {
System.out.println("input score"+names[i]+":");
score[i]=sca.nextInt();
}
int sum=0;
for(int i=0;i<score.length;i++) {
sum+=score[i];
}
System.out.println(sum);
}
}
数组的复制
JDK 提供了以下方法用以实现数组的复制
第一种方法(不推荐)：
System.arraycopy( Object src , int srcPos , Object dest , int destPos , int length);
Object src - 源数组
int srcPos - 源数组的起始位置
Object dest - 目标数组
int destPos - 目标数组的起始位置
int length - 要复制的数组元素个数
案例代码如下：
package day01;
public class Type {
public static void main(String[] args) {
//源数组
int[] ary = {10,20,30,40,50};
//目标数组
int[] copy = new int[6];
System.arraycopy(ary,1,copy,0,4);
for(int i=0;i<copy.length;i++) {
System.out.println(copy[i]);
}
}
}
//运算结果：10 20 30 40 50 0 0
第二种方法：
使用 Java.util. Arrays.copyOf 类用于数组复制，具体用法如下：
type[] newArrays = Arrays.copyOf(tepy original,int newsLength);
这种复制数组的特点是，生成的新数组时原数组的副本，如果 newsLength 小于原数组，则进行截取；如果 newsLength 大于原数组，则用 0 或者 nul l进行填充
代码如下：
package day01;
import java.util.Arrays;
public class Type {
public static void main(String[] args) {
//定义数组
int[] ary = {10,20,30,40,50};
int[] a1 = Arrays.copyOf(ary, 6);
}
}
//运算结果：a1 的数组元素是 10 20 30 40 50 0
数组的扩容
数组的扩容就是创建一个更大的数组，并对将与原有的数组中的内容复制到其中。
可用 Java.util.Arrays.copyOf(); 实现对数组的扩容，具体用法如下：
package day01;
import java.util.Arrays;
public class Type {
public static void main(String[] args) {
//定义数组
//扩容后的数组比原数组长度+1
int[] ary = {10,20,30,40,50};
ary = Arrays.copyOf(ary, ary.length+1);
for(int i=0;i<ary.length;i++) {
System.out.println(ary[i]);
}
}
}
//运算结果：10 20 30 40 50 0
二维数组的定义与初始化
概念：二维数组本质上也是数组，只要在数组中存放数组就组成了二维数组
(1)声明数组并分配空间
int[] [] arr = new int[3] [5];
(2)声明数组，先分配行空间，再分配列空间
int[] [] arr = new int[3] [];
arr[0] = new int[3];
arr[1] = new int[4];
arr[2] = new int[5];
(3)声明数组，分配空间，赋初始值
int[] [] arr= { {1,2,3} , {4,5,6} , {6,7,8} };
数组排序问题的研究
常用的排序算法有插入排序，冒泡排序，快速排序
冒泡排序
排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称之为冒泡排序。
排序的过程：
在第一趟：首先比较第一和第二个数，将小数放在前面，大数放后面；然后比较第二和第三个数，小数放前面，大数放后面，以此类推，直至比较最后两个数，同理第二趟第三趟也是如此
案例代码如下：
package day01;
public class ArrayName01 {
public static void main(String[] args) {
int[] arr = {50,2,33,44,4,6};
//自定义bubblesort方法调用
bubblesort(arr);
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
/*冒泡排序,创建一个方法*/
public static void bubblesort(int[] values){
int temp;
//主体循环
for(int i=0;i<values.length;i++) {
/*内部判定排序大小循环*/
for(int j=0;j<values.length-i-1;j++) {
if(values[j]>values[j+1]) {
//数组元素换位
temp = values[j];
values[j] = values[j+1];
values[j+1] = temp;
}
}
}
}
}
j < values.length - i - 1 解析：
- 1 表示 例如数组 length 长度为 5 ，则只需要相邻排序 4 次即可
- i 表示 原数组开始第一趟冒泡排序完成时，最大的一个数已经在最后面；同理，第二趟排序完成时，最后两个数已经固定(倒数第一，倒数第二)
插入排序
通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
具体算法描述如下：
1.从第一个元素开始，该元素可以被认为已经被排序
2.取出下一个元素(第二个)，在已经排序的元素序列中从后(原来位置上向前)向前扫描
3.如果该元素(已排序、第一个元素)大于新元素，将该元素移到下一位置
4.重复步骤(3),直到找到已排序的元素小于或等于新元素的位置
5.将新元素插入到该位置
6.重复步骤(2)~(5)
案例代码如下：
package day01;
public class ArrayName02 {
public static void main(String[] args) {
int[] arr = {23,12,78,3,1};
//自定义insertsort方法调用
insertsort(arr);
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
/*插入排序,创建方法*/
public static void insertsort(int[] data) {
for(int i=1;i<data.length;i++) {
int key = data[i];
int position = i;
while(position>0 && data[position-1]>key) {
data[position] = data[position-1];
position --;
}
data[position] = key;
}
}
}
Arrays.sort排序(高效排序法)
JDK 提供的更高效的排序方法，可以使用Arrays 类的sort 方法来完成数组的排序
具体如下(1~1000随机数大小排序)：
package day01;
import java.util.Arrays;
//Arrays.sort();排序
public class ArrayName {
public static void main(String[] args) {
int[] arr = new int[100];
for(int i=0;i<arr.length;i++) {
//1~1000 随机数
arr[i] = (int)(Math.random()*1000);
}
//排序
//对一个数组的所有元素进行排序，并且是按从小到大的顺序。
Arrays.sort(arr);
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]+"\t");
if((i+1)%10==0) {
System.out.println("\n");
}
}
}
}