Java基础总结5

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];

 }

 }

输出结果：

练习题

 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();

        }

 }    

 }

输出结果：

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();

 }

 }

输出结果：

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));  

 }

 }

输出结果：

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;

 }

 }

输出结果：

5.知识框架