Java基础知识

java基础知识点

注释

public class Comment {
    public static void main(String[] args) {
        // 单行注释
        System.out.println("hello world!");
        /*
         * 多行注释
         */
    }
}

javadoc 文档注释

    使用javadoc
    Javadoc -d 目标文件夹名 -author -version Javadoc.java
    生成一堆html+css+js网页源码
    可以使用的doc标签，详情查阅

Javadoc 工具可以识别文档注释中的一些特殊标签，这些标签一般以@开头，后跟一个指定的名字，有的也以{@开头，以}结束。Javadoc 可以识别的标签如下表所示：

标签	描述	标签类型
@author	作者标识	包、 类、接口
@deprecated	标识当前API已经过期，仅为了保证兼容性依然存在，以此告之开发者不应再用这个API	包、类、接口、值域、构造函数、 方法
{@docRoot}	指明当前文档根目录的路径
@exception	标志一个类抛出的异常	构造函数、 方法
{@inheritDoc}	从直接父类继承的注释
{@link}	链接到某个特定的成员对应的文档中	包、类、接口、值域、构造函数、 方法
{@linkplain}	插入一个到另一个主题的链接，但是该链接显示纯文本字体	包、类、接口、值域、构造函数、 方法
@param	方法的入参名及描述信息，如入参有特别要求，可在此注释	构造函数、方法
@return	对函数返回值的注释	方法
@see	引用,查看相关内容，如类、方法、变量等	包、类、接口、值域、构造函数、 方法
@serial	说明一个序列化属性
@serialData	说明通过writeObject( ) 和 writeExternal( )方法写的数据
@serialField	说明一个ObjectStreamField组件	@
@since	描述文本,API在什么程序的什么版本后开发支持	包、类、接口、值域、构造函数、 方法
@throws	构造函数或方法所会抛出的异常	构造函数、 方法
{@value}	显示常量的值，该常量必须是static属性	静态值域
@version	版本号	包、 类、接口

/* 
    @author 小明
    @version 1.0
*/
public class Javadoc {
    public static void main(String[] args) {
        // 单行注释
        System.out.println("hello world!");
        /*
         * 多行注释
         */
    }
}

相对路径与绝对路径

相对路径：从当前目录开始定位，形成一个路径
绝对路径：从顶级目录x盘开始定位，形成的路径

常用的dos命令

md 创建文件夹
rd 删除文件夹
dir 查看当前目录有哪些文件、文件夹
cd 切换路径
tree 查看子目录树
cls 清屏
exit 退出DOS

转义字符

\t: 一个制表位
\n 换行符
\\ 一个\
\" 一个"
\' 一个'
\r 一个回车

变量

public class AllVariable {
    public static void main(String[] args){
        /* 
            整型：int
            double
            char
            String
        */
        /* 
            1.变量必须先声明再使用
            2.变量 = 数据类型 + 变量名 + 变量值
        */
        String name = "zhangsan";
        int age = 18;
        char gender = '男'; //为什么不能用"" 而是用''
        double score = 88.8;
        System.out.println(name); // zhangsan
        System.out.println(age); // 18
        System.out.println(gender); // 男
        System.out.println(score); // 88.8
    }
}

+的使用

public class PlusSign {
    public static void main(String[] args){
        /* 
        + 的使用
            当 + 两边的值是数值时，进行加法运算
            当 + 两边的值是字符时，进行拼接运算
            计算顺序：从左到右
        */
        System.out.println(1+"a"); // 1a
        System.out.println(1+2); // 3
        System.out.println(1+2+"a"); // 3a
    }
}

数据类型

[*] 占*字节
        数据类型：
            基本数据类型：
                数值型
                    整数类型：
                        byte[1]
                        short[2]
                        int[4]
                        long[8]
                    浮点类型：
                        float[4]
                        double[8]
                字符型char：char[2]
                布尔型boolean：boolean[1]
            引用数据类型：
                类class(!!!String属于类)
                接口interface
                数组[]

整数类型

1 byte = 8 bit

类型	占用存储空间	数值范围
byte	1字节	-128~127 (-2 ** 8~2 ** 8 -1)
short	2字节	-2 ** 15 ~ 2 ** 15 - 1
int	4字节	-2 ** 31 ~ 2 ** 31 - 1
long	8字节	-2 ** 63 ~ 2 ** 63 - 1

1. java的整数类型，有固定的范围和字段长度，不受操作系统的影响，以保证java程序的可移植性
2. 声明long型常量后面必须要加l负责L
3. 通常情况下，使用int型，当范围不够的时候再使用long型

浮点类型

浮点数（小数）= 符号位 + 指数位 + 尾数位
尾数位容易丢失，所以浮点数都是近似值

类型	占用存储空间	数值范围
float	4字节	-3.403E38~3.403E38
double	8字节	-1.798E308~1.798E308

1. 声明float型常量后面必须要加 f 或者 F
2. 浮点数的两种表示方法
	2.1 十进制表示 0.123 前面的0可以省略
	2.2 科学计数法 5.12e2 = 5.12 x 10 ** 2
3. 我们应该使用double,因为它比float更精确（见下方实例）

public class Test {
    public static void main(String[] args) {
        double num1 = 1.231231231;
        float num2 = 1.231231231F;
        System.out.println(num1); //1.231231231
        System.out.println(num2); //1.2312312 输出的值精度没有double高
    }
}

浮点数相等陷阱

public class Test2 {
    public static void main(String[] args){
        double num1 = 2.7;
        double num2 = 8.1 / 3;
        System.out.println(num1 == num2); //false
        /* 
            判断相等的方法
            判断两个数的差值的绝对值在一个很小的范围即可
            Math.abs 取绝对值
        */
        
        if(Math.abs(num1 - num2) < 0.0000001){
            System.out.println("相等");
        }
    }
}

字符类型

1. char字符必须使用''单引号包裹
2. char本质是一个整数,在输出时,是Unicode对应的字符
3. 使用\转义字符,将其后面的字符变为特殊字符的对应Unicode编码字符
4. 给char类型赋一个整数,在输出时,会按照对应的Unicode字符输出结果
5. char类型相当于一个整数,可以直接进行运算

public class Test3 {
    public static void main(String[] args){
        char c1 = '杰';
        System.out.println((int)c1); // 26480
        char c2 = 26480;
        System.out.println(c2); // 杰
        System.out.println('杰' + 10); //26490
    }
}

布尔类型

1.boolean类型"只"允许取值true和false

java API

java API 中文在线文档

怎么查找: jdk8,11 --> 包 --> 类 --> 方法
离线版自带检索

常见的编码

ASCII: 1个字节表示,一共128个字符(足够存放老外的字母和其它字符)
Unicode:2个字节表示字符,存放字母就比较浪费空间
utf-8:大小可变的编码,字母使用1个字节,汉字使用3个字节
gbk:字母1个字节,汉字2个字节
gb2312:gbk的缩小版
big5:繁体中文

类型转换

基本数据类型之间转换

自动类型转换

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

public class Conversion {
    public static void main(String[] args){
        double num1 = 80;
        System.out.println(num1); // 80.0
    }
}

1. 有多种类型的数据混合运算时,系统首先自动将所有数据都转换成容量最大的数据类型,然后再进行运算
2. 当我们把精度大的赋值给精度小的时,会报错.但是把精度小的赋值给精度大的时,会触发自动类型转换
3. byte,short 不会和 char 发生类型自动转换
4. byte,short,char三者参与运算时,首先都会被转换为int类型,后面再转换为最大精度的类型
5. boolean不参与转换

强制类型转换

自动类型转换的逆过程,将容量大的数据类型转换为容量小的数据类型.使用时要加上强制转换符(),但可能造成精度的损失,需要格外的注意

public class ConversionMandatory {
	public static void main(String[] args){
		int i = (int)1.9;
		System.out.println(i);//1
		/*
			强制类型转换符只针对最近的操作数有效,往往会使用()提升优先级
		*/
		// int x = (int) 10.0/4+3.0;// 报错因为int只会转换10.0/4的值,3.0是double类型,最后自动类型转换值的类型会是double类型
		int x2 = (int)(10.0/4 + 3);
		System.out.println(x2);//5
		/*
			char类型可以保存int的常量值,但不能保存int的变量值
		*/
		char c1 = 100;
		int m = 100;
		// char c2 = m; // 报错
		char c3 = (char)m;
		System.out.println(c1+"-"+c3);// d-d
	}
}

public class ConversionMandatory {
	public static void main(String[] args){
		int i = (int)1.9;
		System.out.println(i);//1
		/*
			强制类型转换符只针对最近的操作数有效,往往会使用()提升优先级
		*/
		// int x = (int) 10.0/4+3.0;// 报错因为int只会转换10.0/4的值,3.0是double类型,最后自动类型转换值的类型会是double类型
		int x2 = (int)(10.0/4 + 3);
		System.out.println(x2);//5
		/*
			char类型可以保存int的常量值,但不能保存int的变量值
		*/
		char c1 = 100;
		int m = 100;
		// char c2 = m; // 报错
		char c3 = (char)m;
		System.out.println(c1+"-"+c3);// d-d
		/* 
			byte和short在进行运算时,当做int类型处理
		*/
		byte a = 1;
		int b = a + 10;
		System.out.println(b);//11
	}
}

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

基本数据类型转String

基本数据类型+ "" 即可

String类型转基本数据类型

通过基本类型的包装类调用parseXX方法即可

public class StringBasic {
    public static void main(String[] args){
        int a = 1;
        String str = a + "";
        System.out.println(str); //1
        System.out.println(Integer.parseInt("123")); //123
        System.out.println(Double.parseDouble("123.1")); //123.1
        System.out.println(Float.parseFloat("1F"));//1.0
        System.out.println(Short.parseShort("123"));//123
        System.out.println(Long.parseLong("123"));//123
        System.out.println(Boolean.parseBoolean("true"));//true
        System.out.println(Byte.parseByte("123"));//123
    }

}

运算符

算术运算符

运算符	描述
+	正号
-	负号
+	加
-	减
*	乘
/	除
%	取模(取余)
i++	先赋值,再自增
++i	先自增,再赋值
i–	先赋值,再自减
–i	先自减,再赋值
+	字符串拼接

public class ArithmeticOperator {
    public static void main(String[] args) {
        /*
         * | + | 正号 |
         * | ---- | ------------- |
         * | - | 负号 |
         * | + | 加 |
         * | - | 减 |
         * | * | 乘 |
         * | / | 除 |
         * | % | 取模(取余) |
         * | i++ | 先赋值,再自增 |
         * | ++i | 先自增,再赋值 |
         * | i-- | 先赋值,再自减 |
         * | --i | 先自减,再赋值 |
         * | + | 字符串拼接 |
         */
        int num1 = 9;
        System.out.println(num1 % 2); // 1
        // 单独使用
        int num2 = 1;
        int num3 = 1;
        num2++;
        ++num2;
        System.out.println(num2); // 3
        num3--;
        --num3;
        System.out.println(num3); // -1
        // 作为表达式使用
        int num4 = 1;
        int num5 = 1;
        int num6 = num4++;
        int num7 = ++num5;
        System.out.println(num6 + "-" + num7); // 1 - 2
        System.out.println(num4 + "-" + num5); // 2 - 2
    }
}

算术运算符练习(常考面试题)

    public class Practice {
    public static void main(String[] args){
        // Practice1
        int i = 1;
        /* 
            i = i++的执行过程
            1. 将 i++ 的值赋值给i
            2. i++ 先赋值再加1
                2.1 将i = 1 的值作为表达式的值参与运算
                2.2 发现右边的表达式没有其它的值了,则进行加1的操作,此时i 加了1,等于2
                2.3 i = i++ 右边表示式执行完毕,将右边的值1进行赋值,i又等于1
        */
        i = i++;
        System.out.println(i); //2

        // Practice2
        int j = 1;
        /* 
            j = ++j的执行过程
            1. 将 ++j 的值赋值给j
            2. j++ 先加1再赋值,此时j的值为2
                2.1 将j = 2 的值作为表达式的值参与运算
                2.2 发现右边的表达式没有其它的值了
                2.3 j = ++j 右边表示式执行完毕,将右边的值2进行赋值,j还是等于2
        */
        j = ++j;
        System.out.println(j); //2

        // Practice3
        int i1 = 10;
        int i2 = 20;
        int i3 = i1++;
        System.out.println(i1); // 11
        System.out.println(i2); // 20
        i3 = --i2;
        System.out.println(i3); // 19
        System.out.println(i2); // 19
    }
}

关系运算符

运算符	描述
==	相等
!=	不等于
<	小于
>	大于
<=	小于等于
>=	大于等于
instanceof	检查是否是类的对象

public class RelationalOperator {
    public static void main(String[] args){
        String str = "abcd";
        // 检测是否是某个类
        System.out.println(str instanceof String); // true
    }
}

逻辑运算符

a	b	a&b	a|b	a&&b	a||b	!a	a^b
true	true	true	true	true	true	false	false
true	false	false	true	false	true	false	true
false	true	false	true	false	true	true	true
false	false	false	false	false	false	true	false

public class LogicalOperator {
    public static void main(String[] args){
        // a^b 逻辑疑惑,两个boolean值相同则为false,不同则为true
        boolean atrue = true;
        boolean afalse = false;
        boolean btrue = true;
        boolean bfalse = false;
        System.out.println(atrue^btrue); //false
        System.out.println(afalse^btrue); //true
        System.out.println(atrue^bfalse); //true
        System.out.println(afalse^bfalse); //false
    }
}

赋值运算符

基本赋值运算符 = 
复合赋值运算符
	+=,-=,*=,/=,%=

三元运算符

条件表达式? 表达式1 : 表达式2;

public class TernaryOperator {
    public static void main(String[] args){
        int a = 1;
        int b = 2;
        String str = a < b ? "是的" : "不是";
        System.out.println(str); // 是的
    }
}

运算符的优先级

优先级	运算符	结合性
1	()、[]、{}	从左向右
2	!、+、-、~、++、–	从右向左
3	*、/、%	从左向右
4	+、-	从左向右
5	«、»、>>>	从左向右
6	<、<=、>、>=、instanceof	从左向右
7	==、!=	从左向右
8	&	从左向右
9	^	从左向右
10	|	从左向右
11	&&	从左向右
12	||	从左向右
13	?:	从右向左
14	=、+=、-=、*=、/=、&=、|=、^=、~=、«=、»=、>>>=	从右向左

标识符

标识符的规则

何为规则?规则就是必须遵守的,必须这么做
	1. 标识符由26个英文字母大小写\数字,_或$组成
	2. 不能以数字开头
	3. 不可以使用关键字和保留字
	4. 严格区分大小写,长度无限制
	5. 标识符中不能包含空格

标识符的规范

何为规范?推荐这么做,做着比较好
	包名: 多单词组成时所有的字母都使用小写 aaa.bbb.ccc
	变量名和方法名: 多单词组成时,第一个字母小写,第二个单词开始首字母大写驼峰命名法
	常量名: 所有字母大写.多字母时每个单词用下划线连接

关键字

被java赋予了一定意义的标识符,我们不能使用
	class interface enum byte short int long float double char boolean void true false null if else switch case default while do for break continue return private protected public abstract final static synchronized extends implements new this super instanceof try catch finally throw throws package import native strictfp transient volatile assert

保留字

准备被java赋予一定意义的标识符,我们不能使用
	byValue cast future generic inner operator outer rest var goto const

键盘输入

使用Scanner类来扫描用户的输入

import java.util.Scanner;
public class MyScanner {
    public static void main(String[] args){
        /* 
            1. 导入包java.util.Scanner
            2. 创建Scanner类
            3. 接收用户的输入
        */
        Scanner scanner = new Scanner(System.in); // System.in 表示键盘输入
        System.out.println("请输入你的名字");
        String name = scanner.next(); // 接收用户的输入,程序才会继续执行
        System.out.println(name);
    }
}

进制

常见的进制

对于整数,有四种常用的表示方式
	二进制: 0b或0B开头
	八进制: 0开头
	十进制:
	十六进制: 0x或0X开头 0~9, A~F 字母不区分大小写

public class main {
    public static void main(String[] args){
        int a = 0b11; // 2进制
        int b = 3; // 10进制
        int c = 003; // 8进制
        int d = 0x3; // 16进制
        System.out.println(a + "-" + b + "-" + c + "-" + d);// 3-3-3-3
    }
}

进制转换

其它进制转十进制

十进制转其它进制

其它进制(非10进制)转其它进制(非10进制)

本人觉得可以通过转10进制来中转一下

位运算

& 按位与 1,1 -> 1 其它情况为0
| 按位或 0,0 -> 0 其它情况为1
^ 按位异或 0,0 -> 0 ; 1,1 -> 0 ; 0,1 -> 1 ; 1,0 -> 1 
~ 按位取反 0 -> 1 ; 1 -> 0
>> 算术右移 低位溢出,符号位不变,用符号位补溢出的高位
<< 算术左移 符号位不变,地位补0
>>> 逻辑右移 低位溢出,高位补0
<<< 无此符号

public class operation {
    public static void main(String[] args){
        int a = 2;// int类型的占4个bit,一个bit占8个字节 2的原码,反码,补码 00000000 00000000 00000000 00000010 
        int b = 3;// 011 00000000 00000000 00000000 00000011
        System.out.println(a&b); // 00000000 00000000 00000000 00000010(补码) --> 正数补码和原码一样 -->2
        /* 
            -2 的原码 
            10000000 00000000 00000000 00000010
            -2 的反码
            11111111 11111111 11111111 11111101
            -2 的补码
            11111111 11111111 11111111 11111110
            取反
            00000000 00000000 00000000 00000001(补码) --> 正数补码和原码一样            
        */
        System.out.println(~ -2); // 1
        /* 
            2的原码\反码\补码(正数三码合一)
            000000000 00000000 00000000 00000010
            取反
            111111111 11111111 11111111 11111101(补码)
            取反补码的原码
            补码 -1 --> 反码
            111111111 11111111 11111111 11111100(反码)
            反码得原码(原码得反码,符号位不变)
            100000000 00000000 00000000 00000011
        */
        System.out.println(~ 2); //3
        /* 
            1 的补码
            00000000 00000000 00000000 00000001
            >>2
            00000000 00000000 00000000 00000000
            三码合一 原码也为上
        */
        System.out.println( 1 >> 2); //0
        /* 
            1 的补码
            00000000 00000000 00000000 00000001
            <<2
            00000000 00000000 00000000 00000100
            三码合一
        */
        System.out.println( 1 << 2); //4
        /* 
            -1 的原码
            10000000 00000000 00000000 00000001
            -1 的反码
            11111111 11111111 11111111 11111110
            -1 的补码
            11111111 11111111 11111111 11111111
            >>>2
            00111111 11111111 11111111 11111111
            三码合一
        */
        System.out.println( -1 >>> 2); // 1073741823
    }
}

原码\反码\补码

1.二进制的最高位是符号位0表示正数1表示负数
2.正数的原码\反码\补码都是一样的
3.负数的补码 = 它的反码+1 负数的反码 = 它的补码 - 1
4.0的反码,补码都是0
5.java中没有无符号数,都是有符号的
6.在计算机中运算的时候,都是按照补码来运算的
7.当我们查看运算结果的时候,要看它的原码

控制结构

顺序控制

程序从上往下执行,中间没有任何的跳转和循环
变量采取向前引用

分支控制

if单分支

if(条件){
	执行代码快;
}

if-else双分支

if(条件){
	执行代码块1;
}else {
	执行代码块2;
}

if-else if-else多分支

if(条件){
	执行代码块1;
}else if(条件){
	执行代码块2;
}else {
	执行代码块3;
}

if(){if()else{}}else {}嵌套分支

if(条件){
	if(条件){
		执行代码块1;
	}else {
		执行代码块2;
	}
}else {
	执行代码块3;
}

switch分支

switch(表达式){
    case 常量1:
    语句块1
    break;
    case 常量2:
    语句块2
    break;
    ...
    default:
    default语句块
    break;
}

注意事项

1、表达式数据类型应该和case后的常量的类型一致，或者是可以自动转成可以相互比较的类型
2、switch中的表达式的返回值必须是（byte,short,int,char,enum,String）
3、case子句中的值必须是常量，而不能是变量
4、default子句是可选的，当没有匹配的case时，执行default

循环控制

for循环

for(循环变量初始化;循环条件;循环变量迭代){
    循环操作语句
}

while循环

while(循环条件){
    循环体；
    循环变量迭代；
}

do-while循环

// 会先执行一次再进行一次判断
do{
    循环体；
    循环变量迭代；
}while(循环条件)

多重循环控制

for(int i=0; i< 4; i++){
    for(int j=0; j< 3; j++){
        System.out.println("*");
    }
}

增强for循环

语法：for(类型名 变量名:数组名){
	变量名是从数组中每一次拿到的那个值
}

Season2[] values = Season2.values();
for(Season2 season2:values){
    System.out.println(season2);
}

跳转控制语句

break

// 条件满足时，跳出循环,一般使用在switch和循环中
public class Breakwhile {
    public static void main(String[] args) {
        while(true){
            int result = (int)(Math.random() * 100);
            if( result == 99){
                System.out.println(result);
                break;
            }else {
                System.out.println(result);
            }
        }
    }
}

break细节

// break可以指定跳到多重循环的某一层for循环,再从跳到的循环上面一层循环开始执行
public class Breakforfor {
    public static void main(String[] args){
        label1:for (int i = 0; i < 3; i++){
            System.out.println("i"+i);
            label2:for (int j = 0; j < 3; j++){
                System.out.println("j"+j);
                for (int k = 0; k < 3; k++){
                    if(k == 1){
                        break label2;
                    }
                    System.out.println("k"+k);
                }
            }
        }
    }
}

continue

// 跳出当前循环，不在执行当前这次循环的后面的代码
public class Continue {
    public static void main(String[] args) {
        for (int i = 0; i <3 ;i++){
            for (int j = 0; j < 3 ; j++){
                if(i == 0){
                    continue;
                }
                // 不可能输出0
                System.out.println(i);
            }
        }
    }   
}

return

// 跳出当前的方法，如果是在主方法里面程序就会执行
public class Return {
    public static void main(String[] args) {
        System.out.println("1");
        for (int i = 0; i < 2; i++) {
            return;
        }
        // 不会执行输出"2"
        System.out.println("2");
    }
}

数组的基本使用

public class array_start {
    public static void main(String[] args) {
        double[] arr = { 1, 2, 3, 4, 5 };
        double total = 0;
        for (int i = 0; i < arr.length; i++) {
            total += arr[i];
        }
        System.out.println(total);
    }
}

数组初始化的方式

动态初始化1

1、double[] arr 等价 double arr[]
2、int[] a = new int[5],开辟一块内存为5的空间

import java.util.Scanner;

public class dynamic_initialization {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        double[] arr = new double[5];
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个值");
            arr[i] = myScanner.nextDouble();
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println("你输入的第" + (i + 1) + "个值是" + arr[i]);
        }
    }
}

动态初始化2

先声明，再分配空间

import java.util.Scanner;

public class dynamic_initialization2 {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        double[] arr;
        // 满足某种条件的时候再分配空间
        if(true){
            arr = new double[5];
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个值");
            arr[i] = myScanner.nextDouble();
        }

        for (int i = 0; i < arr.length; i++) {
            System.out.println("你输入的第" + (i + 1) + "个值是" + arr[i]);
        }
    }
}

静态初始化

如果知道数组的元素的值，可以直接在声明的时候，直接初始化值

public class array_start {
    public static void main(String[] args) {
        double[] arr = { 1, 2, 3, 4, 5 };
        double total = 0;
        for (int i = 0; i < arr.length; i++) {
            total += arr[i];
        }
        System.out.println(total);
    }
}

数组使用的细节

1、数组是多个相同类型数据的组合，满足隐式转换的也可以
int[] arr = {1,2,3,"hello"};
double[] arr = {1.1,2.2,10};
2、数组中的元素可以是基本数据类型也可以是引用数据类型，但是不能混用
3、数组创建后，如果没有赋值，那么都是有默认值的，int,short,byte,long 0 ; float 0.0; double 0.0; char \u0000; boolean false; String null;
4、数组的下标必须在指定的范围之内，否则就是越界 （与JavaScript不同，JavaScript会自动给数组扩容，并且值是undefined）
5、数组属于引用数据类型

数组的赋值

和JavaScript的引用数据类型赋值一样，赋值的是引用关系。共用一块儿内存

数组拷贝

public class copy_an_array {
    public static void main(String[] args) {
        int[] arr1 = {1,2,3,4,5};
        int[] arr2 = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++){
            arr2[i] = arr1[i];
        }
        arr2[4] = 10;
        System.out.println(arr1[4]+"--"+arr2[4]); // 5--10
    }
}

数组翻转

public class array_reverse {
    public static void main(String[] args) {
        int[] arr1 = { 1, 2, 3, 4, 5};
        int[] arr2 = new int[arr1.length];
        for (int i = 0; i < arr1.length; i++){
            arr2[arr2.length - i - 1] = arr1[i];
        }
        for (int i = 0; i < arr2.length; i++){
            System.out.println(arr2[i]);
        }
    }
}

数组扩容

import java.util.Scanner;
/* 
    思路：1、copy原数组长度加1的一个同类型数组
        2、copy的数组添加新元素
        3、将copy的数组赋值给原数组
*/
public class array_capacity {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3 };
        while (true) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入y/n选择是否对数组进行扩容");
            char isChoose = scanner.next().charAt(0);
            if (isChoose == 'y') {
                System.out.println("请输入你要扩容的值");
                int addValue = scanner.nextInt();
                int[] arrCopy = new int[arr.length + 1];
                for (int i = 0; i < arr.length; i++) {
                    arrCopy[i] = arr[i];
                }
                arrCopy[arrCopy.length - 1] = addValue;
                arr = arrCopy;
            } else {
                for (int i = 0; i < arr.length; i++) {
                    System.out.println(arr[i]);
                }
                break;
            }
        }
    }
}

二维数组

二维数组初始化的方式

动态初始化1（一步到位）

int [][] arr = new int[3][3];

动态初始化2（先声明再开辟空间）

int [][]arr;
arr = new int[][];

动态初始化3（列数不确定）

int [][]arr = new int[3][];
for(int i=0; i<arr.length; i++){
    arr[i] = new int[i+1];
}

静态初始化

public class double_dimensional_array {
    public static void main(String[] args) {
        /* 
            1 2 3 
            4 5 6
            7 8 9
        */
        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.println(arr[i][j]);
            }
        }
    }
}

杨辉三角

import java.util.Scanner;

public class yang_hui_triangle {
    public static void main(String[] args) {
        System.out.println("请输入一个数字，表示你要打印一个多少行的杨辉三角");
        Scanner myScanner = new Scanner(System.in);
        int n = myScanner.nextInt();
        int[][] arr = new int[n][];
        for (int i = 0; i < n; i++) {
            arr[i] = new int[i+1];
            for (int j = 0; j < arr[i].length; j++) {
                if (j == 0 || j == arr[i].length - 1) {
                    arr[i][j] = 1;
                } else {
                    arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.println(arr[i][j]);
            }
            System.out.println("\t");
        }
    }
}

二维数组使用的细节

// 二维数组声明的三种方式
int [][] arr = new int[][];
int[] arr[] = new int[][];
int arr[][] = new int[][];