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.知识框架