JavaSE(MAX-1)

已于 2023-08-15 13:55:09 修改
阅读量92 收藏
点赞数
分类专栏： JAVA 文章标签： java
于 2023-08-15 13:39:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_52621162/article/details/132296997
版权

文章目录

1 java概述

1.1转义字符

  • \t 一个制表位，实现对齐功能
  • \n 换行
  • \\ 一个\
  • \" 一个"
  • \r 回车

1.2注释

  • 单行注释: //注释文字

  • 多行注释: /*注释文字*/

  • 文档注释:

    /**
* @author
* @version
*/

1.3代码规范⭐️

  • 类、方法的注释，要以 javadoc 的方式来写
  • 注释详细，着重告述读者为什么这样写，如何修改，注意什么问题等
  • 使用tab、shift + tab
  • 运算符和 = 两边习惯性各加一个空格
  • 源文件使用utf-8编码
  • 行宽度不要超过80字符
  • 代码编写次行风格和行尾风格

1.4 JDK JRE⭐️

  • JDK(java开发工具包)
  • JDK = JRE + java开发工具
  • JRE = JVM + Java的核心类库
  • JVM(java虚拟机)

2 变量

2.1 变量

  • 基本介绍

    变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值)

    int age = 20;
double score = 88;
char gender = '男'；
String name = "jack";
  • 注意事项和细节：
    1. 变量表示内存中的一个存储区域[不同的变量，类型不同，占用的空间大小不同]
    2. 该区域有自己的名称[变量名]和类型[数据类型]
    3. 变量必须先声明，后使用，即有顺序
    4. 该区域的数据可以在同一类型范围内不断变化
    5. 变量在同一个作用域内不能重名
    6. 变量=变量名＋值+数据类型

2.2 基本数据类型⭐️

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WQjxBEnk-1692077480618)(https://xingqiu-tuchuang-1256524210.cos.ap-shanghai.myqcloud.com/3833/%E6%88%AA%E5%B1%8F2022-04-16%20%E4%B8%8B%E5%8D%883.18.09.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yVmm7Hq0-1692077480618)(…/…/…/Library/Application%20Support/typora-user-images/%E6%88%AA%E5%B1%8F2022-09-01%2010.57.09.jpg)]

  • 整数类型 (byte [1] short[2] int[4] long [8])
    1. Java的整型常量(具体值)默认为 int 型，声明long型常量须后加‘l’或‘L’
    2. java程序中变量常声明为int型，除非不足以表示大数，才使用long
    3. bit: 计算机中的最小存储单位，byte：算机中基本存储单元，1byte = 8 bit
  • 浮点(小数)类型 (float [4] double [8])
    1. 浮点数=符号位+指数位+尾数位
    2. 尾部可能丢失，造成精度损失
    3. Java 的浮点型常量(具体值)默认为double型，声明float型常量，须后加’f’或’F’
    4. 十进制数形式：5.12 512.0f .512(必须有小数点)
      科学计数法形式：5.12e2 5.12E-2
    5. 通常情况默认使用double
  • 字符型(Char[2])
    1. 使用单引号表示
    2. Java中还允许使用转义字符来将其后的字符转变为特殊字符型常量
    3. char的本质是一个整数，输出时是unicode码对应字符
    4. char类可以进行运算
  • 布尔型(boolean[1])
    1. boolean类型数据只允许取值true和false，无null
    2. boolean类型占1个字节
    3. 不可以用0或非0的整数代替false和true，与C语言不同

2.3 基本数据类型转化

2.3.1 自动类型转换

  • 基本介绍：

    java程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型

    int = 'c';
double d = 80
  • 转换规则：

    char<int<long<float<double

    byte<short<int<long<float<double

  • 注意事项和细节
  1. 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，再进行计算
  2. 我们把精度(容量)大的数据类型赋值给精度(容量)小 的数据类型时，就会报错，反之就会进行自动类型转换。
  3. byte short char 之间不会相互转换
  4. byte short char 计算是首先转换为int类型
  5. boolean不参与转换
  6. 自动提升原则：表达式结果的类型自动提升为操作数中最大的类型

2.3.2 强制类型转换

  • 基本介绍：

    自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符()，但可能造成精度降低或溢出，格外要注意

    int i = (int)8.8;
System.out.println(i);
  • 注意事项和细节

  1. 当数据从精度 大——＞小，就需要使用到强制转换

  2. 强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级

    int y = int(10*3.5+6*1.5)

  3. char类型可以保存 int的常量值，但不能保存int的变量值，需要强转

    int m = 100;
char c2 = m;//false
char c3 = (char)m;//ture

  4. byte short char 类型在进行运算时，当做int类型处理

2.4 基本数据类型和String类型转换

  • 基本类型转String类型

    语法：将基本类型的值 +” “

    int n1 = 1
float n2 = 1.1f;
double n3 = 3.4;
boolean b1 = true;
String s1 = n1 + "";
String s2 = n2 + "";
String s3 = n3 + "";
String s4 = b1 + "";
  • String类型转基本数据类型

    语法：通过基本类型的包装类调用parseXX方法

    String s5 = "123";
int num1 = InterInt.parseInt(s5);
int num2 = InterInt.parseDouble(s5);
int num3 = InterInt.parseFloat(s5);

3 运算符

3.1 算数运算符

  • 基本介绍：

    算术运算符是对数值类型的变量进行运算的

截屏2022-04-16 下午3.19.01

3.1.1 +号使用

  1. 当左右两边都是数值型时，则做加法运算

  2. 当左右两边有一方为字符串，则做拼接运算

    System.out，println(100 + 98): //198
System.out.println("100" + 98);//10098
System.out.println(100 + 3 +"hello");//103hello
System.out.println("hello"+ 100 +3);//hello1003

3.1.2 ++号使用

  • 前＋＋和后＋+都完全等价子 i=i+1;作为表达式使用

    前++：++先自增后赋值

    后++：i++先赋值后自增

3.1.3 %号使用

  • a % b 当a是小数时，公式 = a - (int)a / b * b

3.2 关系运算符

  • 关系运算符的结果都是 boolean 型
截屏2022-04-16 下午4.09.29

3.3 逻辑运算符

  • 基本介绍：

    用于连接多个条件(多个关系表达式)，结果是boolean

截屏2022-04-16 下午4.20.34

3.3.1 &&和&基本规则

  • && 短路与:

    如果第一个条件为 false ，后面的条件不再判断

  • & 逻辑与:

    如果第一个条件为 false ，后面的条件仍然判断

3.3.2 ||和|基本规则

  • || 短路或:

    如果第一个条件为 true，则第二个条件不会判断，结果为true

  • | 逻辑或:

    不管第一个条件是否为true，第二个条件都要判断

3.3.3 ^逻辑异或

  • 当a和b不同时，则结果为true，否则为false

3.4 赋值运算符

  • 基本介绍：

    赋值运算符就是将某个运算后的值，赋给指定的变量

  • 注意事项和细节：

    1. 运算顺序从右往左

    2. 赋值运算符的左边只能是变量，右边可以是变量、表达式、常量值

    3. 复合赋值： a x= b 等于 a = a x b

    4. 复合赋值运算符会进行类型转换

      byte b = 3;
b += 2;  //等价于 b = (byte)(b + 2)
b++;  //等价于 b = (byte)(b + 1)

3.5 三元运算符

  • 基本语法：
    条件表达式？表达式1：表达式2;

int a = 10;
int b = 99;
int result = a>b ? a++:b--;
  • 运算规则：
    1. 如果条件表达式为true，运算后的结果是表达式1;
    2. 如果条件表达式为false，运算后的结果是表达式2;
  • 注意事项和细节：

    1. 表达式1和表达式2要为可以赋给接收变量的类型(或可以自动转换) 

      int c = a > b ? int(1.1) : int(3.4);

    2. 三元运算符可以转成 if–else语句

3.5 运算符优先级

  • 优先级：
    1. () {} , 等
    2. 单目运算符 ++ –
    3. 算术运算符
    4. 位移运算符
    5. 比较运算符
    6. 逻辑运算符
    7. 三元运算符
    8. 赋值运算符
截屏2022-04-17 上午10.44.16

3.6 标识符的命名规则和规范

  • 规则：
    1. 由26个英文字母大小写，0~9，或＄组成
    2. 数字不可开头
    3. 不可以使用关键字和保留宇，但能包含关键字和保留字
    4. Java中严格区分大小写，长度无限制
    5. 标识符不能包含空格
  • 规范：
    1. 包名：多单词组成时所有字母都小写：aaa.bbb.ccc
    2. 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
    3. 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单河开始每个单词首字母大写：xxxYyyzzz
    4. 常量名：所有字母都大写，多单词时每个单词用下划线连接：XXX_YYY_ZZZ

3.7 关键字、保留字

  • 关键字基本介绍：

    被Java语言赋子了特殊含义，用做专门用途的字符串(单词)

    特点：关键字中所有字母都为小写

截屏2022-04-17 上午11.25.09 截屏2022-04-17 上午11.26.14
  • 保留字基本介绍：

    现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留宇

    byValue、cast、future、 generic、 inner、 operator、outer、rest、var、goto、const

3.8 键盘输入

  • 基本介绍：

    在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取
    lnput.java，需要一个扫描器(对象)，就是 Scanner

  • 步骤：

    1. 导入该类的包，java.util.*

    2. 创建该类的对象(声明变量)

    3. 调用里面的功能

      import java.util.Scanner;
public class hello {
    public static void main(String []args) {
        Scanner myScanner = new Scanner(System.in);//System.in 代表使用键盘输入
        System.out.println("请输入名字");
        String name = myScanner.next();
        System.out.println("请输入年龄");
        int age = myScanner.nextInt();
        System.out.println("名字="+name+ "\t" +"年龄="+age);
    }
}

3.9 进制⭐️

  • 二进制：0.1，满2进1，以0b或0B开头
  • 十进制：0-9，满10进1
  • 八进制：0-7，满8进1，以数字0开头表示
  • 十六进制：0-9及A(10)-F(15)，满16进1.以Ox或0x开头表示，此处的A-F不区分大小写

3.9.1 其他转十进制

  • 从最低位开始，将每个位上的数提取出来，乘以(几进制)的(位数-1)次方

    例：0b01011 = 1 * 2^(1-1) + 1 * 2^(2-1) + 0 * 2^(3-1) + 1 * 2^(4-1) = 1 + 2 + 0 + 8 =11

3.9.2 十进制转其他

  • 将该数不断除(几进制)，直到商为0，每步余数倒写

3.9.3 二进制转八/十六

  • 从低位开始，每三位一组，转成对应八进制
  • 从低位开始，每四位一组，转成对应十六进制

3.9.4 八/十六进制转二

  • 将八进制的每一位，转成对应的一个三位的二进制数
  • 将十六进制的每一位，转成对应的一个四位的二进制数

3.10 原码 反码 补码⭐️⭐️

  • 运算规则：
    1. 二进制的最高位是符号位：0表示正数，1表示负数
    2. 正数的原码、反码、补码都一样(三码合一)
    3. 负数的反码 = 它的原码符号位不变，其它位取反
    4. 负数的补码 = 它的反码+1，负数的反码 = 负数的补码 - 1
    5. 0的反码，补码都是0
    6. java中的数都是有符号的
    7. 计算机运算的时候，都是以补码的方式来运算的
    8. 看运算结果的时候，要看他的原码

3.11 位运算符⭐️

  • 位运算符
    • 按位与 &
    • 按位或 |
    • 按位异或 ^
    • 按位取反 ~
    • 算数右移 >> 低位溢出，符号位不变，并用符号位补溢出的高位(本质/2)
    • 算数左移 << 符号位不变，低位补0(本质*2)
    • 逻辑右移 >>> 低位溢出，高位补0
  • 位运算过程：
    1. 用原码得到补码
    2. 用补码进行相关逻辑运算
    3. 运算完毕将补码转换成原码
IMG_2423 IMG_2424

4 控制结构

4.1顺序

  • 基本介绍：

    程序从上到下逐行地执行，中间没有任何判断和跳转

  • 注意事项和细节：

    Java中定义成员变量时采用合法的前向引用(先定义再引用)

    int num1 = 12;
int num2 = num1 + 2;

4.2 分支控制(if else switch)

4.2.1 单分支

  • 基本语法：
    if(条件表达式){
  执行代码块;
}
  • 注意事项和细节：
    1. 当条件表达式为ture 时，就会执行{}的代码。如果为false，就不执行
    2. 如果{}中只有一条语句，则可以不用{}，建议写上{}

4.2.2 双分支

  • 基本语法：
    if(条件表达式){
  执行代码块;
}else{
  执行代码块2;
}
  • 注意事项和细节：
    1. 当条件表达式成立，即执行代码块1，否则执行代码块2
    2. 如果执行代码块有一条语句，则{}可以省略，否则，不能省略

4.2.3 多分支

  • 基本语法：
    if(条件表达式){
  执行代码块;
}else if(条件表达式2){
  执行代码块2;
}
...
else{
  执行代码块n;
}
  • 注意事项和细节：
    1. 当条件表达式1成立时，即执行代码块1
    2. 如果表达式1不成立，才去判断表达式2是否成立
    3. 如果表达式2成立，就执行代码块2
    4. 以此类推，如果所有的表达式都不成立则执行else的代码块
    5. 多分支可以没有else

4.2.4 嵌套分支

  • 基本介绍：

    在一个分支结构中又完整的嵌套了另个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支

  • 基本语法：
    if(){
  if(){
    //if-else
  }else{
    //if-else
  }
}

4.2.5 switch分支结构

  • 基本语法
    switch(表达式){
    case 常量1:
      语句块1;
      break;
    
    case 常量2:
      语句块2;
      break;
    
    default:
      语句块;
      break;
}
  • 说明：
    1. switch 关键字，表示swtich分支
    2. 表达式对应一个值
    3. case 常量1:当表达式的值等于常量1，就执行语句块1
    4. break ：表示退出swtich
    5. 如果和 case 常量1匹配，就执行语句块1，如果没有匹配，就继续匹配 case 常量2
    6. 如果一个都没有匹配上，执行default
  • 注意事项和细节：
    1. 表达式数据类型，应和case 后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是 int
    2. switch(表达式)中表达式的返回值必须是：(byte,short.int,char,enum,String)
    3. case子句中的值必须是常量,而不能是变量
    4. default子句是可选的，当没有匹配的case时，执行default
    5. break语句跳出switch语句块，如果没有break，程序会执行到结尾

4.3 循环控制(for while do while)⭐️

4.3.1 for循环控制

  • 基本语法：
    for(循环变量初始化;循环条件;循环变量迭代){
  循环操作语句;
}
  • 说明：
    1. 四要素：(1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
    2. 循环操作，这里可以有多条语句，也就是我们要循环执行的代码
    3. 如果 循环操作(语句) 只有一条语句，可以省路{}，建议不要省略
  • 注意事项和细节：
    1. 循环条件是返回一个布尔值的表达式
    2. for(;循环判断条件;)中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略
    3. 循环初始值可以有多条初始化语句，但要求类型一样，井且中间用逗号隔开
    4. 循环变量迭代也司以有名条变量迭代语句，中间用逗号隔开

4.3.2 while循环控制

  • 基本语法
    循环变量初始化;
while(循环条件){
  循环体;
  循环变量迭代;
}
  • 说明：
    1. 四要素：(1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
    2. 四要素位置不同
  • 注意事项和细节：
    1. 循环条件是返回一个布尔值的表达式
    2. while循环是先判断在执行语句

4.3.3 do while循环控制

  • 基本语法
    循环变量初始化;
do{
  循环体;
  循环变量迭代;
}while(循环条件);
  • 说明：
    1. 四要素：(1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
    2. 四要素位置不同
    3. 先执行在判断，至少执行一次
    4. 最后有一个;
  • 注意事项和细节：
    1. 循环条件是返回一个布尔值的表达式
    2. 先执行在判断，至少执行一次

4.3.4 多重循环控制

  • 介绍：
    1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for,while,do.while均可以作为外层循环和内层循环
    2. 嵌套循环就是把内层循环当成外层循环的循环体
    3. 当只有内层循环的循环条件为false时，才会完全跳出内层盾环，才可结束外层的当次循环，开始下一次的循环
    4. 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次

4.4 跳转控制break

  • 基本介绍：

    break语句用于终止某个语句块的执行，一般使用在switch或者循环[for,while,do while]

  • 注意事项和细节：

    1. break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

    2. 标签的基本使用

      label1:{......
  label2:{
  	break label1;
  }  
}

4.5 跳转控制continue

  • 基本介绍：

    • continue语句用于结束本次循环，继续执行下一次循环

    • continue语句出现在多层嵌套的福环语句体中时，可以通过标签指明要跳过的是哪一层循环

  • 注意事项和细节：

    1. continue语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

    2. 标签的基本使用

      label1:{......
  label2:{
  	continue label1;
  }  
}

4.6 跳转控制return

  • 基本介绍：

    return使用在方法，表示跳出所在的方法

5 数组、排序、查找

5.1 数组⭐️

5.1.1 使用方式

1-动态初始化
  • 语法：

    数据类型 数组名 [] = new 数据类型[大小]

    int[] a = new int[5];//创建一个数字名字为a，存放了五个int
  • 数组的引用：

    数组名[下标/索引]，下标从0开始

2-动态初始化
  • 先声明数组：

    数据类型 数组名[]；也可以 数据类型[] 数组名；

    例：int a[];或者int[] a;

  • 再创建数组：

    数组名 = new 数据类型[大小];

    例：a = new int [10];

3-静态初始化
  • 语法：

    数据类型 数组名[] = {元素值，元素值…}

  • 注意事项和细节
  1. 数组是多个相同类型数据的组合
  2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用
  3. 数组创建后如果没有赋值，有默认值:
    int0,short 0, byte 0, long 0, float 0.0,double 0.0
    char \u0000,boolean false, String null
  4. 使用数组的步骤 (1)声明数组并开辟空间(2)给数组各个元素赋值(3)使用数组
  5. 数组的下标是从0开始的
  6. 数组下标必须在指定范围内使用，否则报：下标越界异常
  7. 数组属引用类型，数组型数据是对象(object)

5.1.2 数组赋值机制

  • 数组在默认情況下是引用传递，赋的值是地址

    int arr1 = {1,2,3};
int arr2 = arr1;
arr2[0] = 10;  //arr1[0]=10

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y0Ch51II-1692077480619)(https://xingqiu-tuchuang-1256524210.cos.ap-shanghai.myqcloud.com/3833/%E6%88%AA%E5%B1%8F2022-04-22%2010.41.10.jpg)]

5.1.3 数组拷贝

  • int[] arr1 = {1,2,3};
int[] arr2 = new int[arr1.length];
for (int i = 0;i < arr1.length;i++){
  arr2[i] = arr1[i];
}

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Vu0phw37-1692077480619)(https://xingqiu-tuchuang-1256524210.cos.ap-shanghai.myqcloud.com/3833/IMG_2460.jpg)]

5.1.4 数组反转

  • 规律反转
    public class ArrayReverse01 {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55,66};
        int temp = 0,len = arr.length;
        for (int i = 0;i < len/2;i++){
            temp = arr[len-1-i];
            arr[len-1-i] = arr[i];
            arr[i] = temp;
        }
        for(int i = 0;i < arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
    }
}
  • 逆序赋值
    public class ArrayReverse02 {
    public static void main(String[] args) {
        int[] arr1 = {11,22,33,44,55,66};
        int[] arr2 = new int[arr1.length];
        int len = arr1.length;
        for(int i = len-1;i >= 0;i--){
            arr2[len-i-1] = arr1[i];
        }
        arr1 = arr2;//arr1指向arr2数据空间，此时arr原来的数据空间没有变量引用，会被当作垃圾销毁
        for(int i = 0;i < arr1.length;i++) {
            System.out.print(arr1[i] + "\t");
        }
    }
}

5.1.6 数组添加

  • 静态添加
    public class ArrayAdd01 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        int[] arr2 = new int[arr.length+1];
        for (int i = 0;i < arr.length;i++){
            arr2[i] = arr[i];
        }
        arr2[arr2.length-1] = 4;
        arr = arr2;
        for(int i = 0;i < arr.length;i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}
  • 动态添加
    import java.util.Scanner;

public class ArrayAdd02 {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        double[] arr = {1,2,3};
        do{
            double[] arr2 = new double[arr.length+1];
            for (int i = 0;i < arr.length;i++) {
                arr2[i] = arr[i];
            }
            System.out.println("请输入添加的元素");
            double addNum = myScanner.nextInt();
            arr2[arr2.length-1] = addNum;
            arr = arr2;
            for(int i = 0;i < arr.length;i++) {
                System.out.print(arr[i] + "\t");
            }
            System.out.println("是否继续添加 y/n");
            char key = myScanner.next().charAt(0);
            if(key == 'n'){
                break;
            }
        }while (true);
    }
}
  • 动态删减
    import java.util.Scanner;

public class ArrayReduce01 {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        int[] arr = {1,2,3,4,5};
        while (true){
            int[] arr2 = new int[arr.length-1];
            for (int i = 0;i < arr2.length;i++){
                arr2[i] = arr[i];
            }
            arr = arr2;
            for(int i = 0;i < arr.length;i++) {
                System.out.print(arr[i] + "\t");
            }
            System.out.println("请输入是否删除最后一个数字 yes/no");
            char key = myScanner.next().charAt(0);
            if(key == 'n'){
                break;
            }
        }
    }
}

5.2 二维数组

  • 基本介绍：

    一维数组构成了二维数组

  • 二维数组遍历
    public class TwoDimensionalArrary {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
        for (int i = 0;i < arr.length;i++){
            for (int j = 0;j < arr[i].length;j++){
                System.out.print(arr[i][j]+"\t");
            }System.out.println();
        }
    }
}
  • 二维数组内存图

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-apdpzdzp-1692077480620)(https://xingqiu-tuchuang-1256524210.cos.ap-shanghai.myqcloud.com/3833/%E6%88%AA%E5%B1%8F2022-04-22%2019.40.51.jpg)]

  • 注意事项和细节：
    1. 二维数组元素个数：arr.length
    2. 取出一维元素需要遍历两次
    3. 访问第(i+1)个一维数组的第(j+1)个值 arr [i] [j]

5.2.1 使用方式

1-动态初始化
  • 语法：

    类型 数组名[] [] = new 类型 [大小] [大小]

    public class TwoDimensionalArrary02 {
    public static void main(String[] args) {
        int arr[][] = new int[2][3];
        arr[1][1] = 8;
        for(int i = 0;i < arr.length;i++){
            for(int j = 0;j < arr[i].length;j++){
                System.out.print(arr[i][j]+" ");
            }
            System.out.println();
        }
    }
}
2-动态初始化2
  • 先声明数组：

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

    例：int a[] [];

  • 再创建数组：

    数组名 = new 数据类型[大小] [大小];

    例：a = new int [2] [3];

3-动态初始化-列数不确定
  • public class TwoDimensionalArrary03 {
    public static void main(String[] args) {
        int[][] arr = new int[3][];//创建二维数组，只确定一维数组的个数，一维数组开没有开数据空间
        for(int i = 0;i < arr.length;i++){
            arr[i] = new int[i+1];//给一维数组开空间
            for (int j = 0; j < arr[i].length;j++){
                arr[i][j] = i+1;//给每一个一维数组元素赋值
            }
        }
        for(int i = 0;i < arr.length;i++){
            for (int j = 0; j < arr[i].length;j++){
                System.out.print(arr[i][j]+" ");
            }
            System.out.println(" ");
        }
    }
}
//输出结果：1 22 333
4-静态初始化
  • 语法：

    类型 数组名[] [] = {{值1,值2},{值1,值2},{值1,值2}}

  • 注意事项和细节：
  1. 一维数组声明方式：int [] x 或者 int x []
  2. 二维数组声明方式：int [] [] y 或者 int[] y [] 或者 int y [] []
  3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同

5.3 排序(基础)

5.3.1 排序分类

  1. 想需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择式排序法和插入式排序法)
  2. 数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)

5.3.2 冒泡排序

  • 定义：

    冒泡排序 (Bubble Sorting)的基本思想是：通过对待排序序列从后向前(从下标较大的元素开始)，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒

  • 冒泡排序特点
    1. 一共有n个元素
    2. 一共进行了n-1轮排序，可以看成是外层循
    3. 每1轮排序可以确定一个数的位置，比如第1轮排序确定最大数,第2轮排序，确定第2大的数位置，依次类推
    4. 当进行比较时，如果前面的数大于后面的数，就交换
  • public class BubbleSort {
    public static void main(String[] args) {
        int temp = 0;
        int[] arr = {24,69,80,57,13,321,34,56,7,-4};
        for (int i = 0;i < arr.length-1;i++){
            for(int j = 0;j < arr.length-1-i;j++){
                if(arr[j] > arr[j + 1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println("==排序结果==");
        for(int i = 0;i < arr.length;i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

5.4 查找(基础)

5.4.1 顺序查找

  • import java.util.Scanner;

public class SeqSearch {
    public static void main(String[] args) {
        String[] names = {"白眉鹰王","金毛狮王","紫衫龙王","青翼蝠王"};
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入名字");
        String findName = myScanner.next();

        int index = -1;
        for(int i = 0;i < names.length;i++){
            if(findName.equals(names[i])){
                System.out.println("恭喜找到"+findName);
                System.out.println("序号为"+(i+1));
                index = 1;
                break;
            }
        }
        if(index == -1){
            System.out.println("sorry,没有找到"+findName);
        }
    }
}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

「已注销」

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值