JAVA初学笔记6

路路路小江

已于 2022-09-28 17:38:20 修改

阅读量308

点赞数

分类专栏： java 文章标签： java

于 2022-09-27 19:19:40 首次发布

本文链接：https://blog.csdn.net/Mr_Lujiangduo/article/details/127067094

版权

java 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

二维数组

概念

存储数组的数组

名词

长度:二维数组中一堆数组的个数

元素:一个一堆数据

下标(索引):一堆在二维数组中的位置

步骤

声明

数据类型[ ] [ ] 数组名;

创建

动态创建

带值

数组名 = new 数据类型[ ][ ]{

{值1,值2,...},

{值3,值4,值5,...},

{值6,...},

...

}

不带值

数组名 = new 数据类型[x][y];

x:二维数组中一维数组的个数

y:一维数组中元素的个数,可写可不写

特点:可以将声明与创建分开,也可以同时进行

静态创建

数据类型[ ][ ] 数组名 = {

{值1,值2,...},

{值3,值4,值5,...},

{值6,...},

...

};

操作

改

修改指定位置的一维数组

数组名[下标] = 新的一维数组;

修改指定位置的元素

数组名[下标1][下标2] = 值;

下标1:一维数组在二维数组中的位置

下标2:元素在一堆数组中的位置

修改整个二维数组

数组名 = 新的二维数组

查

查询指定位置的一维数组

数组名[下标]

查询指定位置的元素

数组名[下标1][下标2];

下标1:一维数组在二维数组中的位置

下标:元素在一堆数组中的位置

查询二维数组的长度

数组名.length

注意:长度为二维数组中一堆数组的个数,不是所有元素的个数

特殊情况

遍历

思想:

逐个获取二维数组中的一堆数组

逐个获取一堆数组中的每个元素

杨辉三角

i 
0   1   0   0   0   0   0 
1   1   1   0   0   0   0 
2   1   2   1   0   0   0 
3   1   3   3   1   0   0 
4   1   4   6   4   1   0 
5   1   5   10  10  5   1    
...    
    0   1   2   3   4   5     j

当j==0或j==i时,值为1

j < i 时:当前位置[i][j] = 上一行[i-1][j]+上一行[i-1]+[j-1]

j > i 时:值为0

算法

概念:公式

优点

提高计算机的运算符效率

如:

 //原来的    
int sum = 0;    
for(int i = 1; i < 101; i++){        
    sum = sum + i;    
    }    
System.out.println(sum);        


数学公式:(首项+尾项)*项数/2    
int sum = (1+100)*100/2;

如何判断算法是否优秀

时间复杂度:代码执行的时长,越短越好

空间复杂度:代码在运行占用的内存,内存越少越好

常用的算法

两数交换

int a = 10;
int b = 2;
//找一个中间数记录A
int c = a;
//将B的值赋值给A
a = b;//a = 2;b = 2;
//将中间数的值赋值B
b = c;//a = 2;b = 10;

寻找最值(最大值/最小值)

int[] nums = {10,99,88,101,7,61,34,57,99};
//寻找最大值
//假设一个数为最大值,必须是数组中的数
int max = nums[0];
//循环获取数组中所有的数与假设的最大值比较
for(int i = 0;i < nums.length;i++){
    //获取数组中i位置的值
    int x = nums[i];
    //使用获取的值与假设的最大值比较
    if(x > max){
        max = x;
    }
}
System.out.println("最大值为:"+max);

寻找最值的下标

int[] nums = {10,99,88,101,7,61,34,57,99};
//寻找最小值下标
//假设一个数为最小值下标,要求该数的值在数组下标的取值范围内
int small = 0;
//循环获取数组中所有的数与假设的最小值下标对应的数比较
for(int i= 0;i < nums.length;i++){
    //获取数组中i的位置
    int x = nums[i];
    //判断假设的最小值下标对应的数与获取数组中的数比较
    if(nums[small] > x){
        samll = i;
    }
}
System.out.println("最小值下标为:"+samll);

将最小值或最大值移动到最后

冒泡

思想:相邻比较,交换位置

代码

int[] nums = {10,99,88,101,7,61,34,57,99};

    //注意此时nums.length-1为了防止数组下标越界
    for(int i = 0;i < nums.length-1;i++){
        if(nums[i] < nums[i+1]){
            int x = nums[i];
            nums[i] = nums[i+1];
            nums[i+1] = x;
        }
    }

排序

冒泡排序

int[] nums = {10,99,88,101,7,61,34,57,99};

for(int j = 0;j < nums.length-1;j++){
    //注意此时nums.length-1为了防止数组下标越界
    for(int i = 0;i < nums.length-1;i++){
        if(nums[i] < nums[i+1]){
            int x = nums[i];
            nums[i] = nums[i+1];
            nums[i+1] = x;
        }
    }
}

System.out.println("----------------");
for(int i : nums){
    System.outprintln(i+",");
}

选择排序

int[] nums = {10,99,88,101,7,61,34,57,99};
for(int j = 0; j < nums.length;j++){
    int tagIndex = j;
    int maxIndex = j;
    for(int i = j;i <nums.length;i++){
        if(nums[maxIndex] < nums[i]){
            maxIndex = i;
            }
        }
        if(maxIndex != tagIndex){
            int x = nums[maxIndex];
            nums[maxIndex] = nums[tagIndex];
            nums[tagIndex] = x;
    }
}
for(int i : nums){
    System.out.println(i+",");
}

JDK提供的排序(快速排序)

Arrays.sort(数组);

规则:从小到大