Java基础总结5

深碍√TFBOYSˉ_ 2022-05-19 09:25 146阅读 0赞

**Java基础总结5**

1.多维数组

public class FirstDemo\{

/\*\*

定义多维数组的语法：

数据类型\[\]\[\]数组名=new 数据类型\[行数\]\[列数\];

数据类型 数组名\[\]\[\]=new 数据类型\[行数\]\[列数\];

访问数组中元素的值 通过下标

数组名\[行下标\]\[列下标\]=值;

数组初始化完毕后有默认值null

初始化数组的同时直接赋值

二维数组初始化的时候必须指定行数 列数可以省略

语法：

数据类型\[\]\[\]数组名=\{ \{元素,元素\},\{元素,元素\},\{元素,元素\},\{元素,元素\}\};

元素必须和数据类型保持一致

\*/

//入口方法

public static void main(String\[\]args)\{

//初始化一个3行2列的String类型的数组

//数组下标从0开始

String\[\]\[\]arr=new String\[3\]\[2\];

//给二维数组赋值

//给第一行赋值

arr\[0\]\[0\]="淡酒";

arr\[0\]\[1\]="灵芷";

//给第二行赋值

arr\[1\]\[0\]="大师兄";

arr\[1\]\[1\]="秦时风";

//给第三行赋值

arr\[2\]\[0\]="尊";

arr\[2\]\[1\]="青蛙";

//取出二维数组中的值，通过下标

String tmp=arr\[1\]\[1\];

System.out.println(tmp);

System.out.println(arr\[0\]\[1\]);

//修改数组中的元素 通过下标

arr\[2\]\[1\]="夕颜";

//遍历输出二维数组中所有元素

//外层循环控制行数

for(int row=0;row<3;row++)\{

//内层循环控制列数

for(int col=0;col<2;col++)\{

System.out.print(row+"\\t"+col+"\\t"+arr\[row\]\[col\]+"\\t");

System.out.println();

//初始化一个二维数组并赋值

int\[\]\[\]num=\{ \{1,11\},\{12,21,32\},\{33\}\};

//遍历输出二维数组中所有元素

//外层循环控制行数

for(int row=0;row<num.length;row++)\{

//内层循环控制列数

for(int col=0;col<num\[row\].length;col++)\{

//取出一维数组的长度是num.length

//把二维数组抽象为一维数组 长度就为num\[row\].length

System.out.print(num\[row\]\[col\]+"\\t");

System.out.println();

/\*\*

foreach遍历二维数组

\*/

for(int \[\]temp:num)\{//取出所有行

for(int s:temp)\{

System.out.print(s+"\\t");

//换行操作

System.out.println();

//二维数组初始化的时候必须指定行数

int \[\]\[\]arr1=new int\[2\]\[\];

int \[\]\[\]arr2=new int\[\]\[\]\{ \{2,34,65\},\{11,21\}\};

//给指定行分配指定的列数

arr1\[0\]=new int\[2\];

arr1\[1\]=new int\[3\];

输出结果：

![70][]

练习题

import java.util.\*;

public class Practice1\{

//入口方法

public static void main(String\[\]args)\{

//1.有5个班各5名学生某门课程的成绩，如何计算5个班各自的总成绩和平均成绩？

System.out.println("1.求成绩");

//初始化键盘录入对象

Scanner in=new Scanner(System.in);

//初始化一个5行5列的二维数组

int \[\]\[\]score=new int\[5\]\[5\];

//外层循环控制行数

for(int row=0;row<5;row++)\{

System.out.println("\*\*\*\*\*\*第"+(row+1)+"个班级\*\*\*\*\*\*\*");

//内层循环控制列数

for(int col=0;col<5;col++)\{

//System.out.print("请输入第"+(col+1)+"名学生的成绩：");

//给数组赋值

//score\[row\]\[col\]=in.nextInt();

System.out.println("请输入第"+(col+1)+"名学生的成绩：");

//生成1个1-100的随机数，并给数组赋值

score\[row\]\[col\]=(int)(Math.random()\*100+1);

//打印成绩

//外层循环控制行数

for(int row=0;row<5;row++)\{

int sum=0;

System.out.println("\*\*\*\*\*\*\*第"+(row+1)+"个班级\*\*\*\*\*\*\*");

//内层循环控制列数

for(int col=0;col<5;col++)\{

//求总成绩

sum+=score\[row\]\[col\];

//给数组赋值

System.out.println("第"+(col+1)+"名学生的成绩是："+score\[row\]\[col\]);

System.out.println("第"+(row+1)+"班的总成绩为："+sum);

System.out.println("第"+(row+1)+"班的平均成绩为："+sum/5);

//2.求对角线之和

System.out.println("2.求对角线之和");

//初始化一个3行3列的二维数组

int\[\]\[\]num=new int\[3\]\[3\];

int sum1=0;

//给数组赋值

//外层循环控制行数

for(int row=0;row<3;row++)\{

//内层循环控制列数

for(int col=0;col<3;col++)\{

//生成1个1-100的随机数，并给数组赋值

num\[row\]\[col\]=(int)(Math.random()\*100+1);

//输出矩阵

//外层循环控制行数

System.out.println("3\*3矩阵");

for(int row=0;row<3;row++)\{

//内层循环控制列数

for(int col=0;col<3;col++)\{

System.out.print(num\[row\]\[col\]+"\\t");

//判断元素在对角线上

if(col==row||col+row==2)\{

//求和

sum1+=num\[row\]\[col\];

//换行操作

System.out.println();

System.out.println("对角线之和为："+sum1);

//3.矩阵变换

System.out.println("3.矩阵变换");

//初始化一个2行3列的二维数组

int\[\]\[\]num1=new int\[2\]\[3\];

//给数组赋值

//外层循环控制行数

for(int row=0;row<2;row++)\{

//内层循环控制列数

for(int col=0;col<3;col++)\{

//生成1个1-100的随机数，并给数组赋值

num1\[row\]\[col\]=(int)(Math.random()\*100+1);

//输出原始矩阵

//外层循环控制行数

System.out.println("原始矩阵");

for(int row=0;row<2;row++)\{

//内层循环控制列数

for(int col=0;col<3;col++)\{

System.out.print(num1\[row\]\[col\]+"\\t");

//换行操作

System.out.println();

//初始化一个3行2列的二维数组

int\[\]\[\]num2=new int\[3\]\[2\];

//给数组赋值

//外层循环控制行数

for(int row=0;row<3;row++)\{

//内层循环控制列数

for(int col=0;col<2;col++)\{

num2\[row\]\[col\]=num1\[col\]\[row\];

//输出原始矩阵

//外层循环控制行数

System.out.println("转换后的矩阵");

for(int row=0;row<3;row++)\{

//内层循环控制列数

for(int col=0;col<2;col++)\{

System.out.print(num2\[row\]\[col\]+"\\t");

//换行操作

System.out.println();

//4.打印杨辉三角

System.out.println("4.打印杨辉三角");

//初始化一个10行的二维数组

int \[\]\[\]arr=new int\[10\]\[\];

//外层循环控制行数

for(int row=0;row<10;row++)\{

//给指定行分配列数

arr\[row\]=new int\[row+1\];

//内层循环控制列数

for(int col=0;col<=row;col++)\{

//提取数值不为1的元素

if(row>1&&col>0&&col<row)\{

//计算数值

arr\[row\]\[col\]=arr\[row-1\]\[col-1\]+arr\[row-1\]\[col\];

\}else\{

arr\[row\]\[col\]=1;

System.out.print(arr\[row\]\[col\]+"\\t");

//换行操作

System.out.println();

//杨辉三角解法2

for(int row=0;row<10;row++) \{

int number = 1;

//打印空格字符串

System.out.format("%"+(10-row)\*2+"s","");

for(int col=0;col<=row;col++) \{

System.out.format("%4d",number);

number = number \* (row - col) / (col + 1);

System.out.println();

输出结果：

![70 1][]

2.数组算法

public class SecondDemo\{

/\*\*

冒泡排序，两两进行比较，符合条件交换位置

比较轮数=长度-1

比较次数=长度-1-当前轮数

\*/

/\*\*

选择排序

选择某个索引位置的元素，然后和后面元素依次比较，

若大于则交换位置，经过第一轮比较排序后可得出最小值。

\*/

/\*\*

插入排序

\[2,3,4,1,23,12,43\]

1.有序 2

2.无序 3,4,1,23,12,43

将无序列表的值放入有序列表

2 3

2 3 4

1 2 3 4

1 2 3 4 23

1 2 3 4 12 23

1 2 3 4 12 23 43

先把整个数组看成一个列表

把列表分为两部分 有序和无序

拿无序的数据放到有序列表，然后进行比较，放在合适的位置

\*/

/\*\*

方式1:线性搜索(从头搜到尾/从尾搜到头):indexOf/lastIndexOf

对于元素过多的数组,性能极低:有N个元素,循环次数= (N + 1) / 2;

方式2:二分搜索法/二分查找法/折半查找.

前提:数组元素必须有顺序.

\*/

//入口方法

public static void main(String\[\]args)\{

//冒泡排序

//初始化一个一维数组

System.out.println("冒泡排序");

int \[\]arr=\{2,4,45,3,9,72\};

//比较是拿当前的数和下一个数进行比较

//第一轮比较 2,4,3,9,45,72 比较5次

//第二轮比较 2,3,4,9,45 比较4次

//第三轮比较 2,3,4,9 比较3次

//第四轮比较 2,3,4 比较2次

//第五轮比较 2,3 比较1次

//调用方法

bubbleSort(arr);

//选择排序

System.out.println("选择排序");

int \[\]num=\{13,43,54,12,6,8\};

list(num);

System.out.println("排序后数列");

//执行方法

selectionSort(num);

//插入排序

System.out.println("插入排序");

int \[\]numb=\{23,4,12,76,3,56\};

insertSort(numb);

list(numb);

//查找元素

System.out.println("二分查找");

System.out.println(binarySearch(numb,12));

//冒泡排序

public static void bubbleSort(int\[\]arr)\{

//外层循环控制比较轮数 比较轮数=长度-1=arr.length-1

for(int i=0;i<arr.length-1;i++)\{

//内层循环控制比较次数 每轮比较都可以找到最大数/最小数

//比较次数=长度-1-当前轮数

for(int j=0;j<arr.length-1-i;j++)\{

//比较arr\[j\] arr\[j+1\] 当前数和下个数进行比较

if(arr\[j\]<arr\[j+1\])\{

//交换位置

int tmp=arr\[j\];

arr\[j\]=arr\[j+1\];

arr\[j+1\]=tmp;

//查看数组元素

list(arr);

//选择排序

public static void selectionSort(int \[\]num)\{

//1.比较的轮数的=数组长度-1

//外层循环控制轮数

for(int i=0;i<num.length-1;i++)\{

//声明一个变量 默认将最小数的下标存起来

int p=i;//最小数的下标

//内层循环控制比较次数

//当前的最小数/最大数 给后边所有数进行比较

for(int j=i+1;j<num.length;j++)\{

//p对应的元素和j对应的元素进行比较

if(num\[p\]>num\[j\])\{

//将指针移动到j

p=j;

//一轮比较结束后，需要将最大值/最小值放在i的位置

//判断p位置是否移动

if(p!=i)\{//交换p和i的元素

swap(num,p,i);

//第一轮比较结束后的结果是

list(num);

//插入排序

public static void insertSort(int\[\]numb)\{

//比较的轮数=numb.length-1;

for(int i=0;i<numb.length-1;i++)\{

//插入的数据和以前的数据进行比较

for(int j=i+1;j>0;j--)\{

if(numb\[j\]<numb\[j-1\])\{

swap(numb,j,j-1);

\}else\{

break;

list(numb);

//二分查找法 要求数组都是有序的

public static int binarySearch(int\[\]arr,int element)\{

//声明两个下标 最低位和最高位

int low=0;//低

int hig=arr.length-1;//高位

while(low<=hig)\{

//1.找到中间下标

int mid=(low+hig)/2;

//2.取出中间值和element比较

if(arr\[mid\]==element)\{

return mid;

\}else if(arr\[mid\]<element)\{//猜小了

low=mid+1;//最低位下标右移

\}else\{//猜大了

hig=mid-1;//最高位下标左移

//没找到

return -1;

//交换数组元素的位置

public static void swap(int\[\]num,int firstIndex,int lastIndex)\{

//声明一个变量

int tmp=num\[firstIndex\];

num\[firstIndex\]=num\[lastIndex\];

num\[lastIndex\]=tmp;

//遍历数组

public static void list(int\[\]num)\{

for(int tmp:num)\{

System.out.print(tmp+"\\t");

System.out.println();

输出结果：

![70 2][]

3.Java自带数组工具类Arrays

import java.util.\*;

public class ThirdDemo\{

/\*

Java自带数组工具类Arrays

int binarySearch(type\[\] arr,type key)

使用二分法查找数组里某元素并返回其索引，若找不到返回负数.

void sort(type\[\] arr)

使用调优后的快速法对指定数组排序。

String toString(type\[\] arr)

返回指定数组内容的字符串表示形式。

public static type\[\] copyOf(type\[\] original, int newLength)

复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

\*/

//入口方法

public static void main(String\[\]args)\{

//初始化一个数组

int\[\]arr=\{1,3,2,4,7,8,5\};

//1.将数组转换成String类型

String str=Arrays.toString(arr);

System.out.println(str);

//2.对数组进行排序

Arrays.sort(arr);

System.out.println("排序后的数组"+Arrays.toString(arr));

//3.查找指定的元素

System.out.println(Arrays.binarySearch(arr,3));

//4.复制一个新的数组

int\[\]newArr=Arrays.copyOf(arr,4);

System.out.println(Arrays.toString(newArr));

//5.将数组元素填充指定元素

Arrays.fill(newArr,666);

System.out.println(Arrays.toString(newArr));

输出结果：

![70 3][]

4.numayUtil类常用方法

public class FourDemo\{

/\*\*

numayUtil类常用方法

讨论的都是int类型数组:

打印数组元素:print方法

颠倒数组元素:reverse

获取元素索引:indexOf/lastIndexOf

获取元素最值:getMax/getMin

拷贝数组元素: numaycopy

数组元素排序:sort

二分查询方法:binarySearch

\*/

//入口方法

public static void main(String\[\]args)\{

//初始化一个数组

int \[\]num=\{23,12,34,21,7,4,44\};

//调用print方法

print(num);

//调用reverse方法并输出

reverse(num);

//调用indexs方法查找索引

int n=indexs(num,22);

if(n==-1)\{

System.out.println("该数不在数组中");

\}else\{

System.out.println("索引为："+n);

//调用getMax方法

System.out.println("最大数为："+getMax(num));

//调用getMin方法

System.out.println("最小数为："+getMin(num));

//调用numaycopy方法

numaycopy(num);

//调用sort方法排序

sort(num);

//调用binarySearch方法

int \[\]num1=\{23,44,32,123,435,65,45\};

int m=binarySearch(num1,44);

print(num1);

if(m==-1)\{

System.out.println("该数不在数组中");

\}else\{

System.out.println("索引为："+m);

//打印数组元素:print方法

public static void print(int\[\]num)\{

for(int tmp:num)\{

System.out.print(tmp+"\\t");

System.out.println();

//颠倒数组元素:reverse

public static void reverse(int\[\]num)\{

int \[\]num1=new int\[num.length\];

for(int i=0;i<num.length;i++)\{

num1\[i\]=num\[num.length-1-i\];

print(num1);

//获取元素索引:indexOf/lastIndexOf

public static int indexs(int \[\]num,int query)\{

for(int i=0;i<num.length;i++)\{

if(query==num\[i\])\{

return i;

return -1;

//获取最大值：getMax

public static int getMax(int\[\]num)\{

int tmp=0;

for(int i=0;i<num.length-1;i++)\{

if(num\[i\]>num\[i+1\])\{

tmp=num\[i\];

num\[i\]=num\[i+1\];

num\[i+1\]=tmp;

return num\[num.length-1\];

//获取最小值：getMin

public static int getMin(int\[\]num)\{

int tmp=0;

for(int i=0;i<num.length-1;i++)\{

if(num\[i\]<num\[i+1\])\{

tmp=num\[i\];

num\[i\]=num\[i+1\];

num\[i+1\]=tmp;

return num\[num.length-1\];

//拷贝数组元素: numaycopy

public static void numaycopy(int\[\]num)\{

int \[\]num1=new int\[num.length\];

for(int i=0;i<num.length;i++)\{

num1\[i\]=num\[i\];

print(num1);

//数组元素排序:sort

public static void sort(int\[\]num)\{

//外层循环控制比较轮数

for(int i=0;i<num.length-1;i++)\{

//内层循环控制比较次数 每轮比较都可以找到最大数/最小数

//比较次数=长度-1-当前轮数

for(int j=0;j<num.length-1-i;j++)\{

//比较 num\[j\]  num\[j+1\] 当前数和下个数进行比较

if( num\[j\]<num\[j+1\])\{

//交换位置

int tmp=num\[j\];

num\[j\]=num\[j+1\];

num\[j+1\]=tmp;

//查看数组元素

print(num);

//二分查询方法:binarySearch

public static int binarySearch(int\[\]num,int element)\{

//声明两个下标 最低位和最高位

int low=0;//低

int hig=num.length-1;//高位

while(low<=hig)\{

//1.找到中间下标

int mid=(low+hig)/2;

//2.取出中间值和element比较

if(num\[mid\]==element)\{

return mid;

\}else if(num\[mid\]<element)\{//猜小了

low=mid+1;//最低位下标右移

\}else\{//猜大了

hig=mid-1;//最高位下标左移

//没找到

return -1;

输出结果：

![70 4][]

5.知识框架

![70 5][]

[70]: /images/20220519/3c4973aa04c94ebf9bc0ef9d29556e4e.png
[70 1]: /images/20220519/2fdd3b92b1e24e42bcdf6a144bc9a86e.png
[70 2]: /images/20220519/aaa9e2ff117b4679ab6cb164f876867d.png
[70 3]: /images/20220519/cc3ae0bedffc4e869bee23d885bce709.png
[70 4]: /images/20220519/3c7d2b82f4e14a82961abccf24875616.png
[70 5]: /images/20220519/a85198cb339446e08cd0444a3bdba586.png