[JavaSE] Java基础笔记

不想搬砖ouo

已于 2023-03-23 14:55:53 修改

阅读量249

点赞数 1

分类专栏： Java基础文章标签： java

于 2023-03-13 17:11:56 首次发布

本文链接：https://blog.csdn.net/weixin_50560807/article/details/129493297

版权

Java基础专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、初识Java

1、安装和配置JDK1.8.0_xxx

1）安装：直接使用安装程序，按照安装向导安装即可
注意：安装路径，建议安装在非c，非中文路径下，比如：D:/DevInstall/Java/jdk1.8.0_xxx

2）配置：在此电脑，右击-》属性-》高级系统属性，弹出页面的高级选项卡，环境变量
在下面系统环境变量中：
新增：变量名：JAVA_HOME 变量值：jdk的安装目录
修改：Path环境变量，编辑环境变量，增加一个jdk的配置
即：%JAVA_HOME%\bin;

3）验证：
win+r 快捷键打开运行小窗口，输入cmd，打开命令行窗口
java -version
可以看到jdk的安装版本：
java version “1.8.0_192”
Java™ SE Runtime Environment (build 1.8.0_192-b12)
Java HotSpot™ 64-Bit Server VM (build 25.192-b12, mixed mode)
输入javac，如果直接显示提示改命令的选项，即安装配置成功。

2、Java程序结构

public class HelloJava  {
      public static void main(String[] args)  {
              System.out.println("HelloWorld");
      }
  }

规范：
1、类名与文件名必须完全一致，且首字母大写
2、Java严格区分大小写，System首字母大写
3、main()程序入口，四要素必不可少
4、System.out.println()从控制台输出信息，S大写
5、{和}一一对应，缺一不可，大括号{起始在每行后面，不建议另起一行
6、编译命令：javac 程序文件名执行命令：java 类名
7、注意缩进（格式化代码），输出中文字符串，需要加双引号(英文下的)，输出数值可以不加双引号
8、每行代码，必须是;（英文下）结尾
手动编译运行：
1) javac HelloJava.java 编译源程序
2) 编译后，生成class字节码文件HelloJava.class
3) java HelloJava
运行，命令窗口可以输出HelloWorld

3、控制台输出语法

System.out.print();
   // 不会自动换行，多条语句输出结果在一行
System.out.println();
  //  会自动换行，后续语句输出会另起一行

转义符：\n 是换行符 \t是制表符（相当于键盘的tab按键）

4、代码中的注释

注释分为三类：
1）单行注释 业务代码关键注释居多
// 代码说明注释，或者不需要执行代码
2) 多行注释，注释多行代码，一般都是去除某段代码，又不想删
/* 开头，/结尾，不需要执行代码
3）文档注释（javaDoc注释）注释类和方法
/** 开头，/结尾

5、程序所在包：package

作用：
允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件
有助于实施访问权限控制
防止命名冲突区分名字相同的类

注意：
package的声明必须在源程序代码的第一行

示例：
package com.njxz;
包名的分隔符为：. 并使用分号;进行结尾

规范：
包名由小写字母组成，不能以圆点开头或结尾
包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
包名后续部分依不同机构内部的规范不同而不同

6、包的使用

语法：
import 包名.类名；
作用：在当前类中，导入非当前类所在包外的其它类，在当前类中使用(同包内的其它类不需要import)

示例：

   import java.util.Random;  // 导入java.util包中Random类
   import java.util.*;       // 导入java.util包中所有类，其中 *： 指包中的所有类

注意：
一个类中，package必须位于第一行（忽略注释行），且只允许有一个package语句
一个类中，package和import的顺序是固定的，不能颠倒，先package，后import
一个类中，import不是必须的，如果不需要导入其它包的类，可以没有，如果有，必须在类定义前
一个类中，如果同时引用了两个来自不同包的同名类，必须通过完整类名（全类名）来区分

二、变量、数据类型和运算符

1、变量

变量来源于数学，是计算机语言中能储存计算结果或能表示值抽象概念。变量是一种使用方便的占位符，用于引用计算机内存地址，使用变量并不需要了解变量在计算机内存中的地址，只要通过变量名引用变量就可以查看或更改变量的值。简单使用ppt画笔，画图演示，变量指向值所在的内存空间地址

酒店房间为例：房间对应程序的变量
房间类型对应变量类型
房间号对应变量名
入住客人对应变量值

变量的命名规则

变量命名规则：

首字母：字母，下划线， $ 符
其它：数字，字母，下划线，$ 符

变量命名规范：简短且能清楚地表明变量的作用，通常第一个单词的首字母小写，其后单词的首字母大写。例如：myScore，也称为驼峰命名法
变量命名经验
实际开发时，为了易于维护，尽量使用有意义的变量名，比如性别，就命名为sex，如果直接命名为a，别人不看代码都不知道具体含义

2、java的8种基本数据类型

byte（1个字节）, char（2个字节）, short（2个字节）, int（4个字节）, float（4个字节),
long（8个字节）, double（8个字节）, boolean（只占一位，即1/8字节）

一个字节占八位-bit，范围是-2的八次方到2的八次方-1
在计算机科学中，bit是表示信息的最小单位，叫做二进制位；一般用0和1表示注意：String不是基本数据类型

变量的声明和使用

第一步：声明变量，根据数据类型在内存申请空间
第二步：赋值，即“将数据存储至对应的内存空间”
第三步：使用变量，即“取出数据使用”
注：
第一步和第二步可以合并
数据类型变量名 = 数值;

示例：
每种常用数据类型都简单演示一下定义和使用，注意异常赋值的情况

public static void main(String[] args) {
        double score = 98.5;
        String name = "张三";
        char sex = '男';

        System.out.println("本次考试成绩最高分： " + score);
        System.out.println("最高分得主： " + name);
        System.out.println("性别： " + sex);
    }

注意：局部变量定义后，必须初始化才能使用，否则编译不通过。

常量的声明和使用

常量是已经定义，不可变的，注意常量的写法

//使用的关键字为final 代表最终不可变的
//示例：
public static void main(String[] args) {
    // 计算圆的面积
    final double PI=3.14;
    int r = 2;
    
    // 面积;  
    double area = PI * r * r;
    System.out.println("圆的面积为：" + area);
    
}

优点：比较安全
推荐做法：
（1）常量名通常大写
（2）不同字符使用下划线分隔
（3）只能被赋值一次，通常定义时即对其初始化

3、运算符

赋值运算符：=

将右侧的值（或者变量）赋给左侧的变量

//示例：
    int wangScore = 80;    // 王浩成绩
    int zhangScore;        // 张萌成绩
    // 错误，变量的使用前，必须先赋值
    // wangScore = zhangScore; 
    zhangScore  =  wangScore; //将右边的值给左边的变量
    System.out.println(“张萌成绩是" +zhangScore);

表达式
表达式就是符号（如加号、减号）与操作数（如b，3等）的组合
赋值运算符的运用：
两个值得互换：

    public static void main(String[] args) {
		// 两个值得互换(有中间变量)
		int num1 = 8;
		int num2 = 9;

		System.out.println("交换前：num1=" + num1 + ", num2=" + num2);
		int temp = num1;
		num1 = num2;
		num2 = temp;
		System.out.println("交换后：num1=" + num1 + ", num2=" + num2);
		// 两个值得互换(无中间变量)
		int num3 = 4;
		int num4 = 5;

		System.out.println("交换前：num3=" + num3 + ", num4=" + num4);
		num3 = num3 + num4;
		num4 = num3 - num4;
		num3 = num3 - num4;
		System.out.println("交换后：num3=" + num3 + ", num4=" + num4);
	}

基本算术运算符

+、-、*、/、%、++、-- 、 %，++，-- 的用法

复合算术运算符
+=、-=、*=、/=、%=

示例:

public static void main(String[] args) {
        // 算数运算符
        // 加 +
        int num1 = 98;
        int num2 = 89;
        int sum = num1 + num2;
        System.out.println("两个数之和：" + sum);

        // 减 -
        int mut = num1 - num2;
        System.out.println("两个数之差：" + mut);

        // 乘 *
        int cf = num1 * num2;
        System.out.println("两个数之积：" + cf);
        
        // 除 /
        double sub = num1/num2;
        System.out.println("两个数相除：" + sub);
        
        // 求余数
        int num3 = num2 % 2;
        System.out.println("89与2的余数：" + num3);
        
        // ++ --
        int num4 = 10;
        // ++ -- 写在后面，是先使用后加减
        // int temp = num4;
        // num4 = num4 + 1;
        System.out.println(num4++);
        System.out.println(num4--);
        
        int num5 = 10;
        // ++ -- 写在前面，是先加减后使用
        System.out.println(++num5);
        System.out.println(--num5);
        
        // 复合运算 += -= *= /= %=
        int num6 = 20;
        // num6 = num6 + 10;
        num6 += 10;
        System.out.println(num6);
        
        // 例外
		short num5 = 6;
		num5 += num3;
		// num5 = num5 + num3;
		System.out.println(num5);
    }

练习：会员卡号数字和

public static void main(String[] args) {
		// 练习：计算会员卡号各个位置上数字之和
		Scanner input = new Scanner(System.in);
		System.out.print("请输入会员卡：");
		int vip = input.nextInt();
		int q = vip / 1000;
		int b = vip % 1000 / 100;
		int s = vip / 10 % 10;
		int g = vip % 10;
		System.out.println("千位：" + q + ",百位：" + b + ",十位：" + s + ",个位：" + g);
		System.out.println("各个位置数字之和为：" + (q + b + s + g));
		input.close();
	}

自动、强制类型转换

规则1：如果一个操作数为double型，则整个表达式可提升为double型
规则2：满足自动类型转换的条件
- 两种类型要兼容
- 值类型（整型和浮点型）互相兼容
- 目标类型大于源类型：
- 例如：double 型大于 int 型

示例:

public static void main(String[] args) {
       // 类型转换 自动和强制
		double salary = 8234.5;
		// 自动转换
		double avgSalary = 9000;
		System.out.println(avgSalary);
		// 工资提高1000
		int addSalary = 1000;
		// 新的工资
		double newSalary = salary + addSalary;
		System.out.println(newSalary);
		
		// 强制类型转换
		// 计算日薪，高精度到低精度，强制转换后，自动取整
		int daySalary = (int)(salary / 30 + 30);
		System.out.println("日薪：" + daySalary);
    }

关系运算符

示例：

	public static void main(String[] args) {
		// 布尔类型变量
		double salary = 8000;
		boolean flag = salary > 6000;
		// 日薪是否等于300
		boolean flag1 = salary / 30 != 300;
		System.out.println("工资是否大于6000?" + flag);
		System.out.println("日薪是否等于300?" + flag1);
	}

注意：
=为赋值运算符，== 为等于运算符
关系表达式的结果为布尔值
>、<、>=、<= 运算符的优先级别高于==、!=
>、<、>=、<=运算符只支持数值类型的数据比较

逻辑运算符

&& 短路与两个表达式（操作数）都是true，结果才是true，即第一个表达式为false，不看第二个表达式
|| 短路或两个表达式都是false，结果才是false，即第一个表达式为true，不看第二个表达式
！非操作数为true，结果为false 反之亦然
优先级别
! > && > ||
注意：
如果第一个操作数已经能确定表达式的值，第二个操作数就不必计算了；

示例：

    int x=8;
    int y=9;
    System.out.println((++x==y)&&(++x!=y));// true
    System.out.println(x);// 10

    int x=8;
    int y=9;
    System.out.println( (++x!=y)&&(++x==y));// false
    System.out.println(x);// 9

扩展:

  		// 位运算 & 11为1， | 00为0， ^ 同为0异为1
		// 先转为二进制，然后按位运算 
		int x = 2;
		int y = 3;
		System.out.println(x & y); // 2
		System.out.println(x | y); // 3
		System.out.println(x ^ y); // 1
		// 十进制转二进制口诀：除二取余，然后倒序排列，高位补零

条件运算符

也称为三目（三元）运算符

语法：
条件？表达式1 ：表达式2；
表达式1或者2的类型必须跟定义变量类型一致

示例:

    public static void main(String[] args) {
        // 判断是否为偶数
        // 创建Scanner对象
        Scanner input = new Scanner(System.in);

        // 获取系统输入内容
        System.out.print("请输入一个数：");
        int num = input.nextInt();
        
        // 判断是否为偶数
        // boolean flag = (num % 2 == 0) ? true : false;
        String str = (num % 2 == 0) ? "偶数" : "奇数";
		
        System.out.println(str);
        
        // 三元运算符 
		int salary = 6000;
		// 如果工资小于6000，加薪500，否则加薪200
		int newSalay = salary < 6000 ? salary + 500 : salary + 200;
		System.out.println("调薪后工资为：" + newSalay);
        
    }

三、选择结构

if选择结构

语法：

if(条件表达式){
	......
	  }
//逻辑：当小括号内的条件表达式结果为true时，会执行大括号中的业务逻辑代码块，
//否则跳过大括号中的代码，执行后续代码

示例：

// 系统输入一个java成绩，一个html成绩，根据成绩，评定后给予奖励
public static void main(String[] args) {
		// if选择结构，复杂条件判断
		// 系统输入对象
		Scanner input = new Scanner(System.in);
		
		// 提示输入java成绩
		System.out.print("请输入java考试成绩：");
		int javaScore = input.nextInt();
		
		// 提示输入html成绩
		System.out.print("请输入html考试成绩：");
		int htmlScore = input.nextInt();
		
		// 如果java考试成绩大于90分，且html考试成绩大于80分，奖励HUAWEI手机
		if ((javaScore > 90 && htmlScore > 80) 
				|| (javaScore == 100 && htmlScore > 60) ) {
			System.out.println("考试成绩优秀，奖励一部HUAWEI手机！");
		}
		
		// 如果卷考试成绩等于100分，且html考试成绩大于60分，奖励HUAWEI手机
		// 存在缺陷：当两个条件存在交集时，会导致重复奖励
		/*if (javaScore == 100 && htmlScore > 60) {
			System.out.println("考试成绩优秀，奖励一部HUAWEI手机！");
		}*/
		
		System.out.println("程序结束！");
		input.close();
	}

if + else选择结构

语法：if(条件表达式){
		......
	  } else {
	  	......
	  }

示例：

public static void main(String[] args) {
		// 条件表达式（三元表达式）就是简化版的if+else
		// 逻辑：当if条件表达式结果为true时，会执行if后大括号中的业务逻辑代码块，否则会执行else后的大括号中的代码
		// 示例：系统输入一个工资，调薪
		// 系统输入对象
		Scanner input = new Scanner(System.in);
		
		// 提示输入工资
		System.out.print("请输入员工工资：");
		double salary = input.nextDouble();
		
		// 如果工资大于6000，调薪10%，否则调薪20%
		if (salary > 6000) {
			salary = salary + salary * 0.1;
			System.out.println("调薪10%后，新的工资：" + salary);
		} else {
			salary += salary * 0.2;
			System.out.println("调薪20%后，新的工资：" + salary);
		}
		
		System.out.println("程序结束！");
		input.close();
	}

多重if选择结构

语法：if(条件表达式){
		......
	  } else if(条件表达式) {
	  	......
	  	} else if(条件表达式) {
	  	......
	  	  }

示例：

public static void main(String[] args) {
		// 多重if选择结构基本用法
		// 语法：if(条件表达式){......} [else if(条件表达式) {......} else if(条件表达式) {......} ...] [else {......}]
		
		// 示例：系统输入一个工资，进行等级评定
		// 系统输入对象
		Scanner input = new Scanner(System.in);
		
		// 提示输入工资
		System.out.print("请输入员工工资：");
		double salary = input.nextDouble();
		
		// 不使用多重if选择结构，只使用if选择结构
		// 缺陷：代码实现比较复杂，不利代码维护，效率低，每个if都要判断
		/*if (salary <= 6000) {
			System.out.println("初级开发工程师");
		}
		
		if (salary > 6000 && salary <= 9000) {
			System.out.println("中级开发工程师");
		}
		
		if (salary > 9000 && salary <= 15000) {
			System.out.println("高级开发工程师");
		}*/
		
		
		// 使用多重if选择结构优化
		// 细节1：else 是可以省略的，一般多重最好加上，作为其它情况的例外处理
		// 细节2：多个else if的连续区间判断，不可以随意调换位置，否则判断出错
		if (salary <= 6000) {
			System.out.println("初级开发工程师");
		} else if (salary <= 9000){
			System.out.println("中级开发工程师");
		} else if (salary <= 15000){
			System.out.println("高级开发工程师");
		} else if (salary <= 20000) {
			System.out.println("全栈开发工程师");
		} /*else {
			System.out.println("系统架构工程师");
		}*/
		
		System.out.println("程序结束！");
		input.close();
	}

嵌套if选择结构

语法：if(条件表达式){
		 if (条件表达式){
		      ....
		 }
	  } else {
	  	if (条件表达式){
	  	....
	  	}
	  }

示例：

public static void main(String[] args) {
		// 嵌套if选择结构基本用法
		// 语法：if(条件表达式){ if (条件表达式){....}} else {if (条件表达式){....}} 
		
		// 示例：系统输入一个跑步成绩，判断是否可以进入决赛，如果进入决赛，再根据性别判断进入组别
		
		// 系统输入对象
		Scanner input = new Scanner(System.in);
		
		// 提示输入跑步成绩
		System.out.print("请输入跑步成绩：");
		double runScore = input.nextDouble();
		
		// 根据输入跑步成绩，判断是否进入决赛
		if (runScore < 10) {
			System.out.println("恭喜，进入决赛！");
			
			// 提示输入性别
			System.out.print("请输入性别：");
			String gender = input.next();
			
			// 根据输入的性别，判断是进入男子组还是女子组
			// 强调：字符串比较不能用 ==，不是数值类型，比较的是字符串对象的地址
			// 使用：字符串内容的比较，使用字符串提供的方法： 字符串.equals(其它比较字符串)方法
			// 注意：字符串内容比较，字符串常量要写在前面，避免报空指针
			// gender = null;
			// 规范：嵌套if选择结构，嵌套的层次，最多不能超过3层
			if ("男".equals(gender)) {
				System.out.println("进入男子组决赛！");
			} else {
				System.out.println("进入女子组决赛！");
			}
		} else {
			System.out.println("抱歉，你被淘汰！");
		}
		
		System.out.println("程序结束！");
		input.close();
	}

switch选择结构

public static void main(String[] args) {
		// switch选择结构基本用法
		
		// 示例：根据考试的名次，给予奖励

		// 系统输入对象
		Scanner input = new Scanner(System.in);
		
		// 提示输入考试名次
		System.out.print("请输入考试名次：");
		int scoreNum = input.nextInt();
		
		// 使用多重if选择结构实现
		/*if (scoreNum == 1) {
			System.out.println("荣获第一名，奖励一部HUAWEI笔记本！");
		} else if (scoreNum == 2) {
			System.out.println("荣获第二名，奖励一部HUAWEI手机！");
		} else if (scoreNum == 3) {
			System.out.println("荣获第三名，奖励一部HUAWEI手表！");
		} else {
			System.out.println("未获得名次，谢谢参与，奖励你个锤子！");
		}*/
		
		// switch选择结构实现
		// 优点：结构清晰，更适用于等值判断处理
		// 细节：switch后小括号中，是一个表达式，结果只能是一个具体的值，值的类型包含：int short char byte 枚举 String
		switch(scoreNum){
			case 1:
				System.out.println("荣获第一名，奖励一部HUAWEI笔记本！");
				break;
			case 2:
				System.out.println("荣获第二名，奖励一部HUAWEI手机！");
				break;
			case 3:
				System.out.println("荣获第三名，奖励一部HUAWEI手表！");
				break;
			default:
				System.out.println("未获得名次，谢谢参与，奖励你个锤子！");
				break;
		}
		
		System.out.println("程序结束！");
		input.close();
	}

细节1：switch结构中，case后的匹配值，必须是唯一的
细节2：case后的匹配值，必须是和表达式结果值类型一致
细节3：每个case中的语句，可以写多条（代码块），包括嵌套的选择结构
细节4：switch选择结构中，定义变量，不能重名
细节5：break是用于结束switch选择结构，可以跳出选择结构，执行大括号后面的语句，break可以没有，语法不会报错，但是如果匹配到当前case选项，没有找到break关键字，会自动向下找，直到找到break为止
细节6：default可以没有，如果有，当所有的case选项都没有匹配，会自动执行default，相当于是默认处理，一般都要定义
细节7：default在整个选择结构中，可以定义在任意位置（case里面除外），建议都定义在最后，即便没有break，也不会影响，如果在其它位置，没有写break，会多执行

四、循环结构

1、while循环

语法：

 while ( 循环条件 ) {
            
        //循环操作

    }

特点：
先进行条件判断，如果条件成立，执行循环操作，如果条件不成立，循环操作一次都不执行
注意：
在循环体操作中，要控制循环条件变量的变更（否则死循环）
循环体操作只有一条语句，大括号可以省略（不建议省略）

2、do…while循环

语法：

do {

        //循环操作

    } while ( 循环条件 );

特点：
先执行循环体操作，后执行条件判断，不论条件是否成立，循环操作至少执行一次

注意：
while后面要分号结尾

3、for循环

语法：

for(参数初始化; 条件判断; 循环变量值变更){
        // 循环体
    }

执行顺序：
先初始化–>条件判断–>执行循环体–>循环变量变更
变更之后，再做条件判断，成立，执行循环体，循环变量变更，直到条件不成立
注意点：
1、格式，代码规范，注意缩进
2、初始化变量可以写多个，但是作用域在循环内可见，如果需要循环外获取执行的变量值，需要定义在循环外
3、循环变量的变更也可以写在循环内部，不可以省略
4、条件判断不能省略，否则死循环
5、for(; ; ){…}这个没有语法错误，但是会死循环，相当于while(true){…}

示例：输出加法表

// 系统输入
    Scanner input = new Scanner(System.in);
    System.out.print("请输入一个数值：");
    int num = input.nextInt();
    
    for(int i = 0, j = num; i <= num ; i++, j--){
        // 输出加法表
        System.out.println(i + " + " + j + " = " + (i+j));
    }

常见错误示例：

 // for循环常见写法:初始化和变量赋值是可以省略的，但是分号不能省
    int i = 0; 
    // 两个分号不能省略，等同于while(i<10)
    for (;i < 10;) {
        System.out.println(i);
        i++;
    }
    
    // 没有循环条件:语法不会报错，但是会造成死循环
    int j = 0;
    for(;;j++){
        System.out.println(j);
    }
    
    // 没有给变量重新赋值:语法正常，但是也会造成死循环
    int k = 0;
    for(;k<10;){
        System.out.println(k);
    }
    
    // for循环什么都不写：语法正常，但是也是死循环
    for(;;){
        System.out.println("测试");
    }

4、三种循环的异同点

相同点：
无论哪一种循环结构，都有4个必不可少的部分：
初始部分、循环条件、循环体、更新循环变量
不同点：
1、语法不同
2、执行顺序不同
while 循环：先判断，再执行
do-while循环：先执行，再判断
for循环：先判断，再执行使用场景：
循环次数确定的情况，通常选用for循环
循环次数不确定的情况，通常选用while或do-while循环

五、多重循环和程序调试

1、多重循环语法

for(循环条件1){
     //循环操作1
     for(循环条件2){
          //循环操作2
     }
}

while，或者do-while类似，循环内嵌套循环，三种循环可以相互嵌套

注意：
循环的嵌套，一般不超过两层
原理：外层循环循环执行一次，内层循环执行一遍

2、改变流程关键字

break:
常用于switch结构和循环结构中
break语句终止(跳出)某个循环，程序跳转到循环块外的下一条语句
只能跳出当前所在的循环，不能跳出多重循环
continue：
一般用于循环结构中
continue跳出本次循环，进入下一次循环
不能结束循环，只能跳过某个条件下的循环

3、程序调试

步骤：
1）打断点
2）debug模式运行程序
3）f5:进入方法内部，逐步执行
f6:单步运行（逐行执行代码），没法进入方法内部
f8:断点与断点之间跳转运行
4）发现问题，修改代码
5）关闭调试程序

六、一维数组

1、什么是数组

数组是一个变量，存储是相同数据类型的一组数据。声明数组，就是在内存中划分一串连续的空间
注意：
数组一经定义，大小就确定了，不可以在此基础上再增加空间（重新创建除外），即：不可以动态扩展空间

2、数组的基本要素

数据类型：指定数组中存放的数据类型
标识符：数组名称
数组元素：存放在数组中的数据
下标：从0开始，最大不能大于数组的长度 - 1
注意：
数组长度固定，应避免地址下标越界获取元素

3、定义和使用数组

1）声明数组

方式1：数据类型[] 数组名； - -推荐写法
方式2：数据类型数组名[] ；

2）分配空间使用 new 关键字

数组名 = new 数据类型[数组长度];

注意：
长度必须要定义，代表数组可以存放的元素个数
备注：
数组元素，根据不同的数据类型，会有不同的初始值（数组定义后，不初始化赋值，仍然可以直接访问元素，不会报错，比如：int–0，String–null…）

3）赋值
实际是向分配的内存空间存放数据（实际是地址的引用）
语法：

数组名[下标] = 定义数据类型的值;

声明数组同时赋值：

方式1：数据类型[] 数组名 = {元素1，元素2…};

方式2：数据类型[] 数组名 = new 数据类型[]{元素1，元素2…};

注意：
由于初始化值，已经确定了数组的元素个数，所以，不可以再指定长度边声明边赋值：必须定义在一条语句内，不能分开
比如：
int[] scores = new int[5];
scores = {1,2,3,4,5};

4）数组的使用
数组元素赋值之后，可以重复获取，并使用

4、数组长度

语法：

数组名.length

注意：数组长度，使用的length数组，有别于字符串，字符串长度使用的是length()方法

示例：

for(int i = 0; i < scores.length; i++){
    System.out.println(scores[i]);
}

5、数组求最大值和最小值

原理：
类似打擂台，借助中间表变量，依次比较，保留最大或者最小值

int maxScore = stuScores[0];
		// 循环遍历数组，从第二个学生开始，依次和擂台上的最高分比较，如果分数高于最高分maxScore的值，就将当前学生成绩赋值给擂台上的maxScore，一轮结束，擂台上就是最高分
		for (int i = 1; i < stuScores.length; i++) {
			// 依次判断学生成绩，是否大于擂台上最高分，如果是，就赋值给最高分遍历
			if (stuScores[i] > maxScore) {
				maxScore = stuScores[i];
			}
		}
		
		System.out.println("成绩最高分为：" + maxScore);

6、向数组中插入元素

		//已经确定了顺序数组：	
		// 定义已排序数组，插入一个数值，保证排序不变
		int[] nums = {99, 88, 77, 66, 44, 33, 22, 11};
		
		// 扩容，定义一个新的数组，在原数组长度基础上，加1，用于存放新插入的数值
		int[] newNums = new int[nums.length + 1];
		
		System.out.println("------------原数组-----------");
		System.out.println(Arrays.toString(nums));
		
		// 拷贝原数组的元素，存入新数组，并保证顺序
		for (int i = 0; i < nums.length; i++) {
			newNums[i] = nums[i];
		}
		
		System.out.println("------------新数组-----------");
		System.out.println(Arrays.toString(newNums));
		
		// 系统输入对象
		Scanner input = new Scanner(System.in);
		
		// 提示信息
		System.out.print("请输入要插入的数值：");
		int num = input.nextInt();
		
		// 定义变量，用于保存要插入的位置下标
		int index = -1;
		
		// 遍历新数组，确定要插入数值的下标（原始是降序，只需要找到比谁大，这个位置就是插入位置）
		for (int i = 0; i < newNums.length; i++) {
			// 判断要插入的数值比哪个数大
			if(num > newNums[i]){
				// 找到了插入的位置
				index = i;
				// 立刻结束，后面的数都比当前数小，否则一致比较到最后，插入错误
				break;
			}
		}
		
		// 移动数组元素，从最后开始移动，依次将前面的数值赋值给后面的数值，将插入的位置空出来
		for (int i = newNums.length - 1; i > index; i--) {
			newNums[i] = newNums[i - 1];
		}
		
		System.out.println("------------移动后-----------");
		System.out.println(Arrays.toString(newNums));
		
		// 将要插入的数值，存入要插入的下标位置，即可
		newNums[index] = num;
		
		System.out.println("------------插入后-----------");
		System.out.println(Arrays.toString(newNums));
		
		// 强调：数组用于保存一组相同数据类型的数值，遍历和随机访问元素效率比较高，但是不适用于插入元素（需要移动元素位置），效率低
		
		input.close();

无序数组元素，使用工具类排序示例：

// 已排序数组中插入元素
		int[] scores_old = {88, 66, 55, 99, 22, 33, 77, 11};
		
		// 要插入一个新的数值，必须要讲原始数组进行扩容（原始数组长度+1）
		int[] scores_new = new int[scores_old.length + 1];
		
		// 数组排序和数组内容输出，借助Arrays工具类
		System.out.println("--------------排序前：--------------");
		System.out.println(Arrays.toString(scores_old));
		
		// 排序，默认是升序, 只要调用了该方法，数组中的元素顺序就改变了
		Arrays.sort(scores_old);
		System.out.println("--------------排序后：--------------");
		System.out.println(Arrays.toString(scores_old));
		
		// 拷贝数组-降序排列
		// 使用循环，从后往前输出到新数组
		for (int i = scores_old.length - 1, j = 0; i >= 0; i--, j++) {
			scores_new[j] = scores_old[i];
		}
		System.out.println("--------------降序后：--------------");
		System.out.println(Arrays.toString(scores_new));
		
		// 确定要插入的数值
		Scanner input = new Scanner(System.in);
		System.out.print("输入要插入的成绩：");
		int score = input.nextInt();
		
		// 定义要插入的位置
		int index = -1;
		
		// 遍历数组，找到要插入的位置下标：找到比谁大，这个位置就是要插入的位置
		for (int i = 0; i < scores_new.length; i++) {
			if(score > scores_new[i]){
				index = i;
				// 要立刻结束，否则，index就是最后一个
				break;
			}
		}
		
		// 移动数组内容，从数组的最后一个元素开始，一直到要插入的位置元素结束
		for (int i = scores_new.length - 1; i > index; i--) {
			scores_new[i] = scores_new[i - 1];
		}
		
		// 输出移位后数组内容
		System.out.println("--------------移位后：--------------");
		System.out.println(Arrays.toString(scores_new));
		
		// 将插入的数值，根据定位的下标，重新赋值
		scores_new[index] = score;
		System.out.println("--------------插入后：--------------");
		System.out.println(Arrays.toString(scores_new));
		
		input.close();

7、冒泡排序 – 升序

原理：
每次比较相邻两数
小的交换到前面
每轮结束后最大的数交换到最后

口诀：
冒泡排序速记口诀（升序）
n 个数字来排队
两两相比大靠后
外层循环 n-1
内层循环 n-1-i

示例：

// 冒泡排序算法
        // 初始化一个数组
		int[] nums = {6, 3, 5, 2, 7, 4, 1, 9, 8};
		System.out.println("排序前：" + Arrays.toString(nums));
		// 外层控制轮次（n-1次）
		for (int i = 0; i < nums.length - 1; i++) {
			// 内层控制比较次数
			for (int j = 0; j < nums.length - 1 - i; j++) {
				// 判断，如是升序，大的值靠后，如果是降序，小的值靠后
				if(nums[j] < nums[j + 1]){
					// 两值互换
					int temp = nums[j];
					nums[j] = nums[j+1];
					nums[j+1] = temp;
				}
			}
		}
		System.out.println("排序后：" + Arrays.toString(nums));

8、选择排序

工作原理：首先在未排序的数列中找到最大（小）元素，放到排序数列的起始位置
然后再从剩余未排序的元素中继续查找最大（小）元素，放到已排序数列的末尾（按照次序），依次类推

示例：

public static void main(String[] args) {
		// 选择排序：表现最为文档的一种排序，其排序算计简单直观
		// 初始化一个数列
		int[] nums = {66, 55, 77, 11, 33, 22, 88, 44, 99};
		System.out.println("选择排序前，初始数组：" + Arrays.toString(nums));
		
		// 使用选择排序
		for (int i = 0; i < nums.length; i++) {
			// 记录每次循环起始位置，作为查找参照初识值，如果后续有更小值，记录其下标
			int minIndex = i;
			// 从未排序的数列中查找最小或者最大值
			for (int j = i; j < nums.length; j++) {
				// 两两比较，确定最小或者最大值
				if(nums[j] > nums[minIndex]){
					// 记录已找到最小值的下标，一轮结束，就是未排序数列中的最小值下标
					minIndex = j;
				}
			}
			
			// 将最小值下标对应的值，跟外层循环的起始位置，进行数据交换
			int temp = nums[i];
			nums[i] = nums[minIndex];
			nums[minIndex] = temp;
		}
		System.out.println("选择排序后，排序数组：" + Arrays.toString(nums));
	}

9、Arrays工具类的用法

boolean equals(array1,array2)

比较array1和array2两个数组是否相等

sort(array)

对数组array的元素进行升序排列

String toString(array)

将一个数组array转换成一个字符串

void fill(array,val)

把数组array所有元素都赋值为val

copyOf(array,length)

把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致

int binarySearch(array, val)

查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）

示例：

// 判断两个数组是否相等，必须长度和元素都相等，了解
		int[] scores1 = {78, 67, 89};
		int[] scores2 = {78, 67, 89, 0};
		System.out.println("数组是否相等：" + Arrays.equals(scores1, scores2));

		// 数组填充元素，了解
		int[] scores3 = new int[10];
		System.out.println("默认数组内容：" + Arrays.toString(scores3));
		Arrays.fill(scores3, 100);
		System.out.println("填充后数组内容：" + Arrays.toString(scores3));
		
		// 拷贝数组-扩容，排序，转字符串，掌握
		int[] scores4 = {11, 22, 33, 44, 55};
		// 拷贝前
		System.out.println("默认数组内容：" + Arrays.toString(scores4));
		// 扩容到10个长度
		int[] scores5 = Arrays.copyOf(scores4, 10);
		System.out.println("扩容后数组内容：" + Arrays.toString(scores5));
		// 缩减长度到3
		int[] scores6 = Arrays.copyOf(scores4, 3);
		System.out.println("缩减后数组内容：" + Arrays.toString(scores6));
		
		// 数组元素查找：前置条件-数组的元素必须是升序的，返回的是升序后的元素下标，如果不升序，返回的结果是不准确的，不可以作为查找判断条件
		int[] scores7 = {9, 6, 7, 4, 8, 3, 5, 1, 2};
		System.out.println("默认查找数组内容：" + Arrays.toString(scores7));
		// 要查找是否包含数字3
		// 必须先升序才可以
		Arrays.sort(scores7);
		System.out.println("默认查找数组升序内容：" + Arrays.toString(scores7));
		System.out.println("是否包含数字3，下标值:" + Arrays.binarySearch(scores7, 3));
		
		// 排序，默认是自然排序
		String[] names = {"jerry", "jack", "marry", "mark"};
		System.out.println("姓名数组内容：" + Arrays.toString(names));
		Arrays.sort(names);
		System.out.println("姓名数组排序后内容：" + Arrays.toString(names));

七、二维数组

语法：
<数据类型> [ ][ ] 数组名 = new 数据类型[数组二维长度][数组一维长度];
或者
<数据类型> 数组名[ ][ ] = new 数据类型[数组二维长度][数组一维长度];

注意：
定义二维数组时，要定义最大维数，一维维度可以不定义，且长度不是必须一致的
二维数组实际上是一个以一维数组做为元素的一维数组
通过二维数组名获取长度，返回的是二维的长度，即有几个一维数组

示例：

int [ ][ ] scores = new int[5][]; -- 正确
int [ ][ ] scores = new int[][]; -- 错误

//定义并赋值：
int[][] scores = new int[][]{ { 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 }};
//或者
int scores[][] = {{ 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } };

遍历二维数组：

// 外层是二维长度
		for (int i = 0; i < scores.length; i++) {
			// 内层是一维数组的真实长度
			for (int j = 0; j < scores[i].length; j++) {
				System.out.print(scores[i][j] + " ");
			}
			System.out.println();
		}

示例：

// 按规律输出数字列表
        /**
		 * 特殊数列
		 * 1
		 * 2 6
		 * 3 7 10
		 * 4 8 11 13
		 * 5 9 12 14 15
		 */
		Scanner input = new Scanner(System.in);
		System.out.print("请输入数列的行数：");
		int line = input.nextInt();
		// 定义二维数组存放数据
		int[][] nos = new int[line][line];
		
		// 定义初始值为1，进行累加
		int num = 1;
		
		// 给二维数组赋值
		for (int i = 0; i < nos.length; i++) {
			for (int j = i; j < nos[i].length; j++) {
				nos[j][i] = num++;
			}
		}
		
		// 遍历二维数组，排除默认值0
		for (int i = 0; i < nos.length; i++) {
			for (int j = 0; j < nos[i].length; j++) {
				// 如果是0，不输出
				if(nos[i][j] == 0){
					continue;
				}
				System.out.print(nos[i][j] + " ");
			}
			System.out.println();
		}
		input.close();