一、Java一维数组
1、声明数组变量
dataType[] arrayRefVar; // 首选的方法
或
dataType arrayRefVar[]; // 效果相同,但不是首选方法
double[] arr; //等价于 double arr[];
2、创建数组
dataType[] arrayRefVar = new dataType[arraySize];
另外:
dataType[] arrayRefVar = {value0, value1, ..., valuek};
dataType[] arrayRefVar = new dataType[] {value0, value1, ..., valuek};
double[] arr = new double[3]; //表示创建了默认为3个0.0元素的数组arr
double[] arr = {12.0,12.5,13.2,14.5}; //创建并直接添加元素值
double[] arr = new double[] {12.0,12.5,13.2,14.5}; //创建并直接添加元素值
3、案例1
public class Demo4 {
public static void main(String[] args) {
// 数组大小
int size = 10;
// 定义数组
double[] myList = new double[size];
//给数组写入新的值
myList[0] = 1.0;
myList[1] = 2.0;
myList[2] = 3.0;
myList[3] = 4.0;
myList[4] = 5.0;
myList[5] = 6.0;
myList[6] = 7.0;
myList[7] = 8.0;
myList[8] = 9.0;
myList[9] = 10.0;
// 计算所有元素的总和
double sum = 0;
for (int i = 0; i < size; i++) {
sum += myList[i];
}
System.out.println("总和为: " + sum);
}
}
4、处理数组
数组的元素类型和数组的大小都是确定的,所以当处理数组元素时候,我们通常使用基本循环或者 For-Each 循环(增强for)。
普通for和增强for的区别:
1.增强for只能顺序遍历;
2.增强for不能指定范围遍历,只能遍历所有。
3.增强for不能改变数组元素的值。
//方法1:for循环
public class Arr {
public static void main(String[] args) {
double[] myList = {0.9, 1.9, 2.9, 3.9};
// 打印所有数组元素
for (int i = 0; i < myList.length; i++) {
System.out.print(myList[i] + " ,");
}
System.out.println();
// 计算所有元素的总和
double sum = 0;
for (int i = 0; i < myList.length; i++) {
sum += myList[i];
}
System.out.println("sum is " + sum);
// 查找最大元素
double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max){
max = myList[i];
}
}
System.out.println("Max is " + max);
}
}
/* 方法2:For-Each 循环
for(type element: array)
{
System.out.println(element);
}
*/
public class Arr {
public static void main(String[] args) {
double[] myList = {0.9, 1.9, 2.9, 3.9};
// 只能打印所有数组元素
for (double arr:myList) {
System.out.println(arr);
}
}
}
5、计算数组
5.1、数组求和、均值、最值、中位数、比较(判断)元素
import java.util.Arrays;
import java.util.Scanner;
public class Demo5 {
public static void main(String[] args) {
double[] arr = new double[] {2.2,1.1,2.2,1.1,4.4,5.5,1.1};
double sumArr = 0;
double maxArr = arr[0];
double minArr = arr[0];
for(int i=0;i<arr.length;i++) {
sumArr = sumArr + arr[i];
if (arr[0]<arr[i]) {maxArr = arr[i];}
if (arr[0]>arr[i]) {minArr = arr[i];}
System.out.print(arr[i] + ", ");
}
System.out.println();
System.out.println("计数:"+arr.length);
System.out.println("合计:"+(float) sumArr);
System.out.println("均值:"+ (float)(sumArr/arr.length));
System.out.println("最大值:"+maxArr);
System.out.println("最小值:"+minArr);
//求中位数,需要先排序
Arrays.sort(arr); //从此数组的的顺序就被改变为升序了
if (arr.length % 2 !=0) {
System.out.println("中位数:"+arr[(int) (arr.length / 2.0)]);
}else {
System.out.println("中位数:"+(arr[(int) (arr.length / 2.0)] + arr[(int) (arr.length / 2.0 -1)] )/2.0 );
};
//判断从控制台输入的值是否在数组内,下标值
Scanner superman = new Scanner(System.in);
double n;
System.out.println("输入一个Double类型的数:");
n = superman.nextDouble();
int j=0;
for(;j<arr.length;j++) {
if(arr[j]==n) {System.out.println("存在,下标是:" + j);
break;
}
}
if (j==(arr.length)) {System.out.println("不存在");}
}
}
6、数组排序(冒泡、选择、插入、快速排序)
6.1、冒泡排序
冒泡排序:是将数组中的两个相邻的元素进行比较,并将最小的元素交换到前面,多轮比较交换位置,直到全部比较完毕
//数组排序:冒泡排序
public class Demo6 {
//升序
public static void main(String[] args) {
double[] array = new double[] {1.0,2.2,5.6,3.5,4.9};
double box = 0;
for (int i = 0;i<(array.length - 1);i++) { //排序轮次array.length-1次
for (int j=0;j<(array.length - 1 - i);j++) { //每轮对比次数
if(array[j] > array[j+1]){ //相邻的比较
box = array[j];
array[j] = array[j+1];
array[j+1] = box;
}
}
}
for (double array1:array) {
System.out.println(array1);
}
}
}
6.2、选择排序
选择排序:某个位置和这个位置后的所有元素比较。
package test;
//选择排序:某个位置和这个位置后的所有元素比较。
public class Demo7 {
//升序
public static void main(String[] args) {
double[] array = new double[] {5.2, 6.2, 7.2, 3.2, 4.2,0.1};
double box = 0.0;
for(int i =0;i<(array.length-1);i++) { //位置
for(int j =i+1;j < array.length;j++) {
if(array[i]>array[j]) {
box = array[i];
array[i] = array[j];
array[j] = box;
}
}
}
for (double array1:array) {
System.out.println(array1);
}
}
}
6.3、插入排序
某个位置与前边所有元素比较,这个位置的元素比前边元素小,那么把这个位置的元素插入到比它大的那个元素的位置。
//插入排序:某个位置(第2,3,...,array.length-1位置)与前边所有元素比较,
//升序
//这个位置的元素比前边元素小,
//那么把这个位置的元素插入到比它大的那个元素的位置。
public class Demo9 {
//升序
public static void main(String[] args) {
int[] array = new int[] {8,5,9,4,3,6,7,2,1};
int box ;
for (int i = 1;i<array.length;i++) { //位置
for (int j = 0;j<i;j++) { //位置前边所有元素比较
if(array[i]<array[j]) {
box=array[i]; //拿出位置上的元素
for(int k = i;k>j;k--) { //插入覆盖
array[k] = array[k-1];
}
array[j] = box;
}
}
}
for (int array1:array) {
System.out.println(array1);
}
}
}
6.4、快速排序法
6.4.1、快速排序法--降序排序
![java快速排序--降序](https://i-blog.csdnimg.cn/blog_migrate/f598e5c0ccb3db22b811e2698aba0318.png)
public class Demo12 {
//java快速排序法--降序
public static void main(String[] args) {
// 定义一个数组
int[] array = {1,3,5,7,9,2,4,6,8,10,5};//任意数组
//调用快速排序的方法
quickSort( array, 0, array.length-1);
//遍历输出数组
for(int i=0;i<array.length;i++) {
System.out.print(array[i] + ", ");
}
}
/*
定义一个方法,用来进行快速排序
*/
public static void quickSort(int[] array, int left, int right) {
//前提条件,左边索引应该是小于右边索引的
if( left> right ) {return; }
//定义一个变量存基准数
int base = array[left];
//定义变量i,指向最左边
int i = left;
//定义变量j,指向最右边
int j = right;
while (i != j) { //当i != j时
//第一轮:
//当i和j不相撞时,先由j从右往左检索,直到检索到小于基准数的就停下
while(array[j]<=base && i<j) {
j--; //j向左移动,直到找到>=base的位置
}
//i从左向右检索,直到检索到大于基准数的就停下
while(array[i]>=base && i<j) {
i++; //i向右移动,直到找到<=base的位置
}
//i和j都停下来了,就交换这两个位置的元素
if(i<j) {
int box ;
box = array[i];
array[i] = array[j];
array[j] = box;
}
}
//当跳出循环i=j时,把相撞位置的数与基准数交换
array[left] = array[j];
array[j] = base;
//基准数归为,左边都大(>=),右边都小(<=)
//第二轮
//排基准数的左边,排法和第一轮一样,调用第一轮的方法。
quickSort(array, left, j - 1);
//排右边
quickSort(array, j+1,right);
}
}
6.4.2、快速排序法--升序
![java快速排序法--升序原理](https://i-blog.csdnimg.cn/blog_migrate/a4dbf418cda65176a97f361987ae1a7f.png)
public class Demo10 {
//java快速排序法:升序
public static void main(String[] args) {
// 定义一个数组
int[] array = {6,4,3,5,1,9,8,7,2,6,9,0,10};//任意数组
//调用快速排序的方法
quickSort( array, 0, array.length-1);
//遍历输出数组
for(int i=0;i<array.length;i++) {
System.out.print(array[i] + ", ");
}
}
/*
定义一个方法,用来进行快速排序
*/
public static void quickSort(int[] array, int left, int right) {
//前提条件,左边索引应该是小于右边索引的
if( left> right ) {return; }
//定义一个变量存基准数
int base = array[left];
//定义变量i,指向最左边
int i = left;
//定义变量j,指向最右边
int j = right;
while (i != j) { //当i != j时
//第一轮:
//当i和j不相撞时,先由j从右往左检索,直到检索到小于基准数的就停下
while(array[j]>=base && i<j) {
j--; //j向左移动
}
//i从左向右检索,直到检索到大于基准数的就停下
while(array[i]<=base && i<j) {
i++; //i向右移动
}
//i和j都停下来了,就交换这两个位置的元素
if(i<j) {
int box ;
box = array[i];
array[i] = array[j];
array[j] = box;
}
}
//当跳出循环i=j时,把相撞位置的数与基准数交换
array[left] = array[j];
array[j] = base;
//基准数归为,左边的都比他小,右边的都比他大
//第二轮
//排基准数的左边,排法和第一轮一样,调用第一轮的方法。
quickSort(array, left, j - 1);
//排右边
quickSort(array, j+1,right);
}
}
7、二分法查找数组元素
要点:必须先排序,再进行二分查找。
package test;
//二分法查找元素
import java.util.Scanner;
public class Demo11 {
public static void main(String[] args) {
Scanner superman = new Scanner(System.in);
int[] array = new int[] {8,3,5,7};
//冒泡排序法
int box;
for (int i=0;i<array.length;i++) {
for(int j=i+1;j<array.length;j++) {
if (array[i]>array[j]) {
box=array[i];
array[i] = array[j];
array[j] = box;
}
}
}
for (int array1:array) {
System.out.println(array1);
}
//二分法查找元素
System.out.println("请输入需要查找的元素:");
int value = superman.nextInt();
int start = 0;
int end = array.length-1;
int middle = (start+ end)/2;
while(value !=array[middle] ){
if(value < array[middle] ) {
end = (middle-1);
}else if(value > array[middle]) {
start= (middle+1);
}
if (end<start) {
middle = -1;
break;
}
middle = (start+ end)/2;
}
if(middle == -1) {
System.out.println("不存在" );
}else {
System.out.println("存在,第" +middle +"元素" );
}
}
}
8、数组的复制方法及java.util.Arrays类的使用
import java.util.Arrays;
public class Demo13 {
//将一个数组存放到另外一个数组中去
public static void main(String[] args) {
int[] array = {22,20,13,9,17};
//--方法1:-------------------------------------------------------------------
System.out.println("方法1");
//让array1也指向array数组存放的内存地址
int[] array1 = array; //直接像变量赋值一样用等于符号
for (int arr:array1) {
System.out.print(arr + ", ");//输出数组
}
//两个的内存地址是相同的,重点哈
System.out.println("\n" + array); //输出array内存地址
System.out.println(array1);//输出array1内存地址
//--方法2:------------------------------------------------------------------------
System.out.println("方法2");
//数组的克隆,创建并返回一个副本
int[] array2 = array.clone();
for (int arr:array2) {
System.out.print(arr + ", ");//输出数组
}
//既然是副本,那么内存地址就是不相同的,重点哈
System.out.println("\n" + array); //输出array内存地址
System.out.println(array2);//输出array2内存地址
//--方法3:------------------------------------------------------------------------
System.out.println("方法3");
//创建一个长度相同的空数组,然后遍历赋值
int[] array3 = new int[array.length];
for (int i = 0;i<array.length;i++) {
array3[i] = array[i];
}
for (int arr:array3) {
System.out.print(arr + ", ");//输出数组
}
//既然是新建赋值,那么内存地址就是不相同的,重点哈
System.out.println("\n" + array); //输出array内存地址
System.out.println(array3);//输出array2内存地址
//--方法4:------------------------------------------------------------------------
System.out.println("方法4");
//用系统自带的类复制,System.arraycopy(src, srcPos, dest, destPos, length);
//src:源数组;srcPos:复制的起始位置;dest:目标数组;destPos:目标数组粘贴的起始位置; length:复制数组的长度
int[] array4 = new int[array.length];//创建数组
System.arraycopy(array, 0, array4, 0, array.length);
for (int arr:array4) {
System.out.print(arr + ", ");//输出数组
}
//既然是新建复制粘贴,那么内存地址就是不相同的,重点哈
System.out.println("\n" + array); //输出array内存地址
System.out.println(array4);//输出array2内存地址
//--方法5:------------------------------------------------------------------------
System.out.println("方法5");
//导入java.util.Arrays的类进行操作
//copyOf(源数组,复制长度少于则截取,多了0来补):复制数组
int[] array5 = Arrays.copyOf(array2, array2.length);
System.out.println(Arrays.toString(array5));
//copyOfRange :指定范围复制
// int[] array5_0 = Arrays.copyOfRange(array2,0, array2.length);
// System.out.println(Arrays.toString(array5_0));
//--常用的Arrays类方法:----------------------------------------------------
System.out.println("常用的Arrays类方法:");
//导入java.util.Arrays;的类进行操作
//常用的Arrays类方法:
//toString:字符串的形式展示数组
System.out.println(Arrays.toString(array));
//sort/parallelSort:对数组进行排序
Arrays.sort(array1); //对数组进行升序(快速排序)
System.out.println(Arrays.toString(array1));//字符串形式查看数组
Arrays.sort(array2, 1, 3);//指定位置排序,这里的排序位置为[1,3),重点啊半闭半开,前闭后开,
//1指的是第2个元素,3指第4个元素,但3是开区间,最后一个位置是不参与的
System.out.println(Arrays.toString(array2));//字符串形式查看数组
//binarySearch(a, key):二分查找法,前提是需要排序,a为数组,key为需要查找的元素
Arrays.sort(array2);
System.out.println(Arrays.binarySearch(array2, 17));//返回排序后的下标
//当查找值不存在时,返回负的插入点-1
System.out.println(Arrays.binarySearch(array1, 10));
//binarySearch,支持范围查找
System.out.println(Arrays.binarySearch(array1, 0, 2, 13));
//equals:判断两个数组是否相同,对应位置都相同返回true
System.out.println(Arrays.equals(array1, array3));
//fill:填充(替换)数组,不指定范围全部替换填充,当然可以指定填充替换 也是半开半闭[n1,n2)
Arrays.fill(array2, 0, 1, 222);
System.out.println(Arrays.toString(array2));
//copyOf(源数组,复制长度少于则截取,多了0来补):复制数组
int[] array5_1 = Arrays.copyOf(array2, array2.length);
System.out.println(Arrays.toString(array5_1));
//copyOfRange :指定范围复制同样范围半开半闭
int[] array5_2 = Arrays.copyOfRange(array2, 2, 4);
System.out.println(Arrays.toString(array5_2));
}
}
9、一维数组综合操作案例
import java.util.Scanner;
public class Demo8 {
public static void main(String[] args) {
//(1)阶段:定义数组,添加数组元素,输出数组
//定义数组,
String[] array1 = new String[100];//会员编号
String[] array2 = new String[100] ;//会员生日
int[] array3 = new int[100] ;//会员积分
//添加数组
array1[0]= "v1001";
array2[0]= "12/20";
array3[0]= 1800;
array1[1]= "v1002";
array2[1]= "10/03";
array3[1]= 2000;
array1[2]= "v1003";
array2[2]= "11/09";
array3[2]= 2000;
System.out.println("会员编号\t会员生日\t会员积分");
//输出数组
for(int i = 0;i<array1.length;i++) { //输出已有会员信息
if (array1[i] ==null ) {break;}
System.out.println(array1[i]+ "\t"+ array2[i]+ "\t"+ array3[i]);
}
//(2)第二阶段,添加控制台循环输入添加新会员信息
Scanner superman = new Scanner(System.in);
String next;
System.out.print("是否添加新会员(y/n):");
next = superman.next();
while (next.equals("y")) {
for (int j=0;j<array1.length;j++) {
if(array1[j]==null && array2[j]==null && array3[j]==0) {
System.out.print("输入会员编号:");
array1[j] = superman.next();
System.out.print("输入会员生日(月/日):");
array2[j] = superman.next();
System.out.print("输入会员积分:");
array3[j] = superman.nextInt();
break;
}
}
System.out.print("是否继续输入新会员(y/n):");
next = superman.next();
}
//(3)第三阶段:输出会员列表,并找到积分最大的会员,如果最值存在多个一起找到
System.out.println("------------添加新会员后的会员列表----------------------");
System.out.println("会员编号\t会员生日\t会员积分");
int maxArray3 = array3[0];
for(int i = 0;i<array1.length;i++) {
if (array3[i] ==0 ) {
break;
}else {
if(maxArray3<array3[i]) {maxArray3 = array3[i];} //找最值
System.out.println(array1[i]+ "\t"+ array2[i]+ "\t"+ array3[i]);
}
}
System.out.println("最高积分为:" + maxArray3);
//找最值对应的下标,输出会员信息
for(int i = 0;i<array3.length;i++) {
if(array3[i] != 0) {
if( maxArray3 == array3[i]) {
System.out.println(array1[i]+ "\t"+ array2[i]+ "\t"+ array3[i]+"目前积分最高");
}
}else {break;}
}
}
}
二、java二(多)维数组
二维数组在java中也相当于一维数组
行\列 | 0列 | 1列 |
0行 | 15 | 5 |
1行 | 8 | 18 |
2行 | 10 | 3 |
存储原理
1、声明二维数组变量
类型[][] 变量名;
int [][] array;
double[][] arr;
2、创建二维数组
dataType[][] arrayRefVar = new dataType[rowLength][columnLength];
int[][] array = new int[3][2];
另:
int[][] array;
array = int[3][2];
3、创建二维数组并赋值
import java.util.Arrays;
import java.util.Scanner;
//二维数组
public class Demo14 {
public static void main(String[] args) {
//静态初始化
// int [][] array = {{15,5},{8,18},{10,3}};
int [][] array = new int[][] {{15,5},{8,18},{10,3}};
//按照单个元素赋值
// int [][] array; //申明一个整数型的2维数组
// array= new int[3][2]; //创建一个3行2列的二维数组
// array[0][0] = 15; //给数组赋值
// array[0][1] = 5;
// array[1][0] = 8;
// array[1][1] = 18;
// array[2][0] = 10;
// array[2][1] = 3;
//控制台给数组赋值
// int[][] array = new int[3][2];
// Scanner superman = new Scanner(System.in);
System.out.println(array.length);//结果为3行
// System.out.println("输入元素:");
// for(int i = 0;i<array.length;i++) {
// for(int j=0;j<array[i].length;j++) {
// array[i][j] = superman.nextInt();
// }
// }
//输出数组
for (int i = 0 ;i<array.length;i++) { //行
for(int j =0;j<array[i].length;j++) { //列
System.out.print(array[i][j] + "\t");
}
System.out.println();
}
//计算2维数组--按照行求和
int sum = 0;
for (int i =0;i<array.length;i++) {
sum = 0;//清零
for(int j = 0;j<array[i].length;j++) {
sum += array[i][j];
}
System.out.println(sum);
}
}
}
三、不规则数组
public class Demo15 {
//不规则数组
public static void main(String[] args) {
// int[][] array = new int[3][];
array[0] = new int[2];
array[1] = new int[3];
array[1] = new int[4];
// array[0] = new int[] {4,6};
// array[1] = new int[] {2,5,3};
// array[2] = new int[] {2,1,4,3};
int[][] array = {{4,6},{2,5,3},{2,1,4,3}};
// int[][] array = new int[][] {{4,6},{2,5,3},{2,1,4,3}};
for(int i = 0;i<array.length;i++) {
for(int j = 0;j<array[i].length;j++) {
System.out.print(array[i][j] + "\t");
}
System.out.println();
}
}
}