数组是一组数据,可以存放多个同一类型的数据;数组本身也一种数据类型,属于引用类型 ;
1、数组的初始化: 1.1动态初始化:- 语法:
数据类型 数组名[] = new 数据类型[数组大小];//数组的初始元素默认为0 int a[] = new int[5]; //创建一个数组,名字为a,存放5个int数据。
package com.muyu.javase.array;
public class ArrayDemo1 {
public static void main(String[] args) {
int array[] = new int[5]; //初始化数组,在堆中开辟一个容量为5的数组空间
// 打印数组每个值
for (int i = 0; i < 5; i++) {
System.out.print(array[i] +"t");// 0 0 0 0 0
}
}
}
- 数组的引用;
数组名[下标/索引] 数组的下标是从0开始。1.2 动态初始化2
- 语法:
1. 声明数组:数据类型 数组名[]; 2. 创建数组空间: 数组名 = new 数据类型[数组大小];
package com.muyu.javase.array;
public class ArrayDemo1 {
public static void main(String[] args) {
int array[]; // 声明数组
array = new int[5]; //初始化数组,在堆中开辟一个容量为5的数组空间
// 打印数组每个值
for (int i = 0; i < 5; i++) {
System.out.print(array[i] +"t");// 0 0 0 0 0
}
}
}
1.3 静态初始化
- 语法
数据类型[] 数组名 = {元素值1,元素值2,...};
当知道数组的具体大小和元素的具体值的时候,就可以使用静态初始化方式。
package com.muyu.javase.array;
public class ArrayDemo2 {
// 求数组的总和与平均值
public static void main(String[] args) {
double[] hens = {2.0, 3.5, 1.8, 3.0, 2.1};
double sum = 0;
double average;
for (int i = 0; i < hens.length; i++) {
sum += hens[i];
}
average = sum/hens.length;
System.out.println("数组的总和为:"+sum+"t"+"数组的平均值为:"+average);
}
}
2、数组使用注意事项和细节
- 数组是多个相同类型数据的组合;
- 数组中的元素可以是任何数据类型,包括基本类型和引用类型,但数据类型必须单一,不能混用。
- 数组创建后,如果没有赋值,使用默认值:
int 0; short 0;byte 0; long 0; float 0.0; double 0.0; char u0000; boolean false; String null;
- 使用数组的步骤:1)声明数组并开辟空间;2)给数组各个元素赋值;3)使用数组
- 数组的下标是从0开始。
- 数组下标必须在规定范围内使用,否会报下标越界异常。
- 数组属于引用类型,数组型数据时对象(object)
基本数据类型的赋值(值传递),就是将这个值复制了一份给变量,变量的值改变不会影响原数值。
package com.muyu.javase.array;
public class AssignDemo1 {
//基本数据类型的赋值
public static void main(String[] args) {
char aph = 'A';
char re_aph = aph;
System.out.println("aph:"+aph+"tre_aph:"+re_aph);//aph:A re_aph:A
re_aph = 'B';
System.out.println("aph:"+aph+"tre_aph:"+re_aph);//aph:A re_aph:B,re_aph的改变不影响aph的值
}
}
数组在默认情况是引用传递(地址传递),赋的值是地址。
package com.muyu.javase.array;
public class AssignDemo1 {
//基本数据类型的赋值
public static void main(String[] args) {
//数组类型赋值
int[] array1 = {1,2,3,4};
int[] array2 = array1;
System.out.println("n====array1====");
for (int i = 0; i < array1.length; i++) {
System.out.print(array1[i]+"t"); //1 2 3 4
}
System.out.println("n====array2====");
for (int i = 0; i < array2.length; i++) {
System.out.print(array2[i]+"t"); //1 2 3 4
}
//=======================================================================
System.out.println("n修改array中元素以后");
array2[1] = 10;
System.out.println("====array1====");
for (int i = 0; i < array1.length; i++) {
System.out.print(array1[i]+"t"); //1 10 3 4
}
System.out.println("n====array2====");
for (int i = 0; i < array2.length; i++) {
System.out.print(array2[i]+"t"); //1 10 3 4 //array2与array1指向的是同一个地址
}
}
}
数组的赋值是将堆中开辟的内存地址进行引用
如果两个数组或者多个数组指向的都是同一个地址,那么任何一个数组中的元素改变,都会影响其余的数组。
3.1 数组的拷贝将数组array1中元素拷贝得到array2中,且两个数组互不影响
package com.muyu.javase.array;
public class CopyArrayDemo {
//将数组array1中元素拷贝得到array2中,且两个数组互不影响
public static void main(String[] args) {
int[] array1 = {1,2,3,4,5};
//初始化array2,开辟一个新的与array1大小一样的数组空间
int[] array2 = new int[array1.length];
//将array1中元素遍历,并赋值到array2中
for (int i = 0; i < array1.length; i++) {
array2[i] = array1[i];
}
for (int i = 0; i < array2.length; i++) {
System.out.print(array2[i]+"t");
}
}
}
3.2 数组翻转
package com.muyu.javase.array;
public class FlipArrayDemo {
//翻转数组
public static void main(String[] args) {
int[] array1 = {1,2,3,4,5};
//数据中转
int temp = -1;
//数组长度
int len = array1.length;
//翻转元素
for (int i = 0; i < len/2; i++) {
temp = array1[i];
array1[i] = array1[len-i-1];
array1[len-i-1] = temp;
}
for (int i = 0; i < len; i++) {
System.out.print(array1[i]+"t");
}
}
}
3.3数组扩容
package com.muyu.javase.array;
import java.util.Scanner;
public class AddArrayDemo {
//数组扩容
public static void main(String[] args) {
int[] array1 = {1,2,3,4,5};
do {
int len = array1.length;
System.out.println("请输入要添加的元素:");
Scanner input = new Scanner(System.in);
int a = input.nextInt();
//创建新的数组
int[] array2 = new int[len+1];
//将array1中元素赋值到array2中;
for (int i = 0; i < len ; i++) {
array2[i] = array1[i];
}
//将要添加的元素赋值到array2中并放在array1最后一个元素的后面;
array2[len] = a;
//array1指向新的数组空间
array1 = array2;
for (int i = 0; i < array1.length; i++) {
System.out.print(array1[i]+"t");
}
System.out.println("是否继续添加:y/n");
Scanner confirm = new Scanner(System.in);
char key = confirm.next().charAt(0);
if (key == 'n'){
break;
}
}while (true);
}
}
3.4数组缩减
package com.muyu.javase.array;
import java.util.Scanner;
public class ReduceArrayDemo {
//数组缩减
public static void main(String[] args) {
int[] array1 = {1,2,3,4,5};
do {
int len = array1.length;
System.out.println("请输入要删除的数:");
Scanner input = new Scanner(System.in);
int a = input.nextInt();
//开辟新的数组空间
int[] array2 = new int[len-1];
int len2 = array2.length;
//array2数组下标
int index = 0;
//将数组array1中的元素赋值到array2中,如果元素是要删除的元素就跳过,进入下一元素
for (int i = 0; i < len; i++){
if (array1[i]==a){
continue;
}
if (index==len2){
break;
}
array2[index] = array1[i];
index++;
}
//array1指向新的数组空间
array1 = array2;
for (int i = 0; i < array1.length; i++) {
System.out.print(array1[i]+"t");
}
if (array1.length==1){
System.out.println("已经是最后一个元素,不允许删除");
break;
}
//是否继续删除
System.out.println("是否继续删除:y/n");
Scanner confirm = new Scanner(System.in);
char key = confirm.next().charAt(0);
if (key == 'n'){
break;
}
}while (true);
}
}
4、排序和查找
4.1 排序
排序是将多个数据,依据指定的顺序进行排列的过程
排序的分类:
- 内部排序:将需要处理的所有数据都加载到内部存储器中进行排序。(交换排序,选择排序和插入排序)
- 外部排序:数据量过大,无法全部加载到内存中,需要借助外部存储进行排序。(合并排序法和直接合法并排序法)
package com.muyu.javase.array;
public class BubbleSortDemo1 {
//冒泡排序
public static void main(String[] args) {
int[] arrary = {24,50,16,40,59,77};
int temp = -1;
for (int i = 0; i < arrary.length; i++) {
for (int j = i+1; j < arrary.length ; j++) {
// 如果前面的数大于后面的数,就将两个数互换
if(arrary[i]>arrary[j]){
temp = arrary[i];
arrary[i] = arrary[j];
arrary[j] = temp;
}
}
}
for (int i = 0; i < arrary.length; i++) {
System.out.print(arrary[i]+"t");
}
}
}
4.2 搜索
- 顺序查找:从头到尾或者从尾到头的搜索顺序进行查找。
package com.muyu.javase.array;
import java.util.Scanner;
public class SeqSearchDemo {
//顺序搜索
public static void main(String[] args) {
String[] people = {"Java","Python","C++","C","GO","JavaScript"};
do {
Scanner input = new Scanner(System.in);
System.out.println("输入查询的编程语言:");
String key = input.next();
//记录下标
int index = -1;
for (int i = 0; i < people.length; i++) {
//从头开始查询,如果能匹配到,就输出下标
if (people[i].equals(key)){
index = i;
System.out.println(people[i]+"下标为:"+index);
break;
}
}
//如果下标没变过,说明没有查询到
if (index == -1){
System.out.println("未搜索到内容");
}
//是否继续查询
System.out.println("是否继续查询:y/n");
Scanner quit = new Scanner(System.in);
char y_quit = quit.next().charAt(0);
if(y_quit == 'n'){
break;
}
}while (true);
}
}
- 二分查找:当数组是已排序的数组时,可以使用二分查找;
package com.muyu.javase.array;
public class BinarySearchDemo {
//二分查找
public static void main(String[] args) {
int[] array = {1,3,4,8,9,22,25};
int len = array.length;
int num = 9;
int left = 0;
int right = len-1;
while (left<=right){
//二分
int mid = (left+right)/2;
if (array[mid]==num){
System.out.println("下标:"+mid);
break;
//区间右移
}else if (array[mid] < num){
left = mid + 1;
//区间左移
}else {
right = mid - 1;
}
}
}
}
5、二维数组
5.1 二维数组的定义
二维数组是指一位数组里面的元素也是一个一位数组。
5.2 二维数组的使用- 动态初始化1。
语法:
数据类型[][] 数组名 = new 数据类型[大小][大小]
package com.muyu.javase.array;
public class TwoDimensionalDemo1 {
//二维数组 int[4][4],第一个[4]表示第一个一维数组的大小(或者说是行)
//第二个[4]表示第一个一维数组中的一维数组的大小(或者说是列)
public static void main(String[] args) {
int[][] twoArray = new int[4][4];//四行四列的二维数组
for (int i = 0; i < twoArray.length; i++) {
for (int j = 0; j < twoArray[0].length; j++) {
System.out.print(twoArray[i][j]+"t");
}
System.out.println();
}
}
}
- 动态初始化2
先声明:数据类型[][] 数组名; 再定义:数组名 = new 数据类型[大小][大小] 再赋值:for循环
package com.muyu.javase.array;
public class TwoDimensionalDemo2 {
public static void main(String[] args) {
int[][] twoArray;//先声明
twoArray = new int[4][4];//再开辟数组空间
//赋值
for (int i = 0; i < twoArray.length; i++) {
for (int j = 0; j < twoArray[0].length; j++) {
twoArray[i][j] = j;
}
}
//打印
for (int i = 0; i < twoArray.length; i++) {
for (int j = 0; j < twoArray[0].length; j++) {
System.out.print(twoArray[i][j] + "t");
}
System.out.println();
}
}
}
- 动态初始化-列数不确定
数据类型[][] 数组名 = new 数据类型[大小][]
package com.muyu.javase.array;
public class TwoDimensionalDemo3 {
//不确定列
public static void main(String[] args) {
int[][] twoArray = new int[4][];
for (int i = 0; i < twoArray.length; i++) {
// 动态为每一列开辟数组空间
twoArray[i] = new int[i+1];
//赋值
for (int j = 0; j < twoArray[i].length; j++) {
twoArray[i][j] = i;
}
}
//输出twoArray
for (int i = 0; i < twoArray.length; i++) {
for (int j = 0; j < twoArray[i].length; j++) {
System.out.print(twoArray[i][j]+"t");
}
System.out.println();
}
}
}
- 静态初始化
数据类型[][] 数组名 = {{value1,value2...},{value1,value2...},{value1,value2...}...};
package com.muyu.javase.array;
public class TwoDimensionalDemo4 {
//静态初始化,打印杨辉三角
public static void main(String[] args) {
int[][] array = new int[5][];
for (int i = 0; i < array.length; i++) {
//初始化嵌套的一位数组
array[i] = new int[i+1];
for (int j = 0; j < array[i].length; j++) {
if (j==0 || j==array[i].length-1){
array[i][j] = 1;
}else {
array[i][j] = array[i-1][j-1] + array[i-1][j];
}
}
}
//打印
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j]+" ");
}
System.out.println();
}
}
}
5.3 二维数组使用细节和注意事项
- 二维数组的声明方式:
1、 数据类型[][] 数组名; 2、 数据类型[] 数组名[];//不建议使用 3、 数据类型 数组名[][];
- 二维数组实际上是由多个一位数组组成的,他的各个一位数组的长度可以相同,也可以不相同。



