Java基础学习笔记及总结

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量245 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27122705/article/details/104448322
版权

学习记录不是按照每日学习记录，是按照课程的相关安排进行的。笔记只是为了方便日后返回头查看遗忘的知识点，并观看对应的相关视频。

导航

Day01

1.基础及环境

1.1 常用的DOS命令级快捷键
  • dir:列出文件及文件夹
  • md:创建目录
  • rd:删除目录
  • cd:进入目录
  • cd…:退回上级目录
  • cd:退回根目录
  • del:删除文件
  • exit:退出dos命令行
    补充:echo javase>1.doc
  • ←→:移动光标
  • ↑↓:调阅历史命令
  • Delete和Backspace:删除字符
1.2 开发环境搭建及path环境变量配置
  • JDK=JRE+开发工具集(例如Javac编译工具等)
  • JRE=JVM+Java SE标准类库

下载: 到oracle官网,一路下一步.

path环境变量配置:
JAVA_HOME= jdk地址
path设置:%JAVA_HOME%\bin;
扩展:set path=%path% 配置临时环境

2.总结及作业

2.1 第一个Java程序HelloWorld总结
/*
对第一个java程序进行总结
1.Java程序编写-编译-运行的过程
编写：我们将编写的Java代码保存在以“.java”结尾的源码文件中
编译：使用javac.exe命令编译我们的java源文件。格式：javac 源文件名.java
运行：使用java.exe命令解释运行我们的字节码文件。格式：java 类名

2.在一个java原文件中可以声明多个class。但是，只能最多有一个类声明为public的。
而且要求声明为public的类的名必须与源文件名相同。

3.程序的入口是main()方法。格式是固定的。

4.输出语句：
System.out.println():先输出数据，然后换行
System.out.print():只输出数据

5.每一行执行语句都以“；”结束

6.编译的过程：编译以后，会生存一个或多个字节码文件，字节码文件的文件名与java源文件中的类名相同。


*/
public class Hello 
{
	public static void main(String[] args) //arguments：参数
	{
		System.out.println("Hello World!");
	}
}

class Person
{
}

class Animal
{
}
2.2 今日作业

1.JDK,JRE,JVM三者之间的关系，以及JDK、JRE包含的主要结构有哪些?

JDK = JRE + Java的开发工具（javac.exe,java.exe,javadoc.exe）
JRD = JVM + Java核心类库

2.为什么要配置path环境变量？如何配置？

JAVA_HOME = bin的上一层目录
path = %JAVA_HOME%\bin

3.常用的几个命令行操作都有哪些？(至少4个)

cd
md
rd
del
cd…
cd/

4.创建如下的类，使得运行的话可以输出：

创建java文件：ChairMan.java

 public class ChairMan{
 
	public static void main(String[] args){
		System.out.println("姓名：Kay\n");//
		//System.out.println();
		System.out.println("性别：男");
		System.out.println("家庭住址：北京中南海");
	
	}
 
 }

5.编译和运行上述代码的指令

编译：javac ChairMan.java
运行：java ChairMan

3.其他补充

Editplus工具添加:

Javac:

  • 参数:$(Filename)
  • 起始目录:$(FileDir)

Java:

  • 参数:$(FileNameNoExt)
  • 起始目录:$(FileDir)

4.感想

希望能一直坚持下去,努力学习~第一天结束!

Day02

1.关键字与保留字

在这里插入图片描述
在这里插入图片描述
**保留字：**goto、const

2.标识符的使用

1.标识符：凡是自己可以起名字的地方都叫标识符。
比如：类名、变量名、方法名、接口名、包名…

2.标识符的命名规则：–> 如果不遵守如下的规则，编译不通过！需要大家严格遵守

由26个英文字母大小写，0-9 ，_或 $ 组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。

  1. Java中的名称命名规范： —>如果不遵守如下的规范，编译可以通过！建议大家遵守

包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

3.变量（重点）

3.1 变量的使用

  1. java定义变量的格式：数据类型 变量名 = 变量值;

  2. 说明：
    ① 变量必须先声明，后使用
    ② 变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了
    ③ 同一个作用域内，不可以声明两个同名的变量

3.2 Java定义的数据类型

一、变量按照数据类型来分：

基本数据类型：
整型：byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean

引用数据类型：
类(class)
接口(interface)
数组(array)

二、变量在类中声明的位置：
成员变量 vs 局部变量

3.3 基本数据类型之间的运算规则

**前提:**这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。

1. 自动类型提升:

结论:当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
byte 、char 、short --> int --> long --> float --> double

特别的:当byte、char、short三种类型的变量做运算时，结果为int型

2. 强制类型转换：
自动类型提升运算的逆运算。
1.需要使用强转符：()
2.注意点：强制类型转换，可能导致精度损失。

此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量

3.4 String类型变量的使用
  1. String属于引用数据类型,翻译为：字符串
  2. 声明String类型变量时，使用一对""
  3. String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
  4. 运算的结果仍然是String类型

Day03

1.运算符

1.1 算术运算符

+ - + - * / % (前)++ (后)++ (前)-- (后)-- +

%： 取余运算
结果的符号与被模数的符号相同
开发中，经常使用%来判断能否被除尽的情况。

(前)++： 先自增1，后运算
(后)++： 先运算，后自增1
注意点：
s1 = s1 + 1;//编译失败
s1 = (short)(s1 + 1);//正确的
s1++;//自增1不会改变本身变量的数据类型

(前)-- : 先自减1，后运算
(后)-- : 先运算，后自减1

1.2 赋值运算符

**= += -= *= /= %= **

注意点：
s1 = s1 + 2;//编译失败
s1 += 2;//结论：不会改变变量本身的数据类型

开发中，如果希望变量实现+2的操作，有几种方法？(前提：int num = 10;)
方式一：num = num + 2;
方式二：num += 2; (推荐)

开发中，如果希望变量实现+1的操作，有几种方法？(前提：int num = 10;)
方式一：num = num + 1;
方式二：num += 1;
方式三：num++; (推荐)

1.3 比较运算符

== != > < >= <= instanceof

结论：
1.比较运算符的结果是boolean类型
2.区分 == 和 =

class CompareTest {
	public static void main(String[] args) {
		int i = 10;
		int j = 20;

		System.out.println(i == j);//false
		System.out.println(i = j);//20

		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1);//false
		System.out.println(b2 = b1);//true
	}
}
1.4 逻辑运算符

& && | || ! ^

说明：
逻辑运算符操作的都是boolean类型的变量

class LogicTest {
	public static void main(String[] args) {
		
		//区分& 与 &&
		//相同点1：& 与  && 的运算结果相同
		//相同点2：当符号左边是true时，二者都会执行符号右边的运算
		//不同点：当符号左边是false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
		//开发中，推荐使用&&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}

		System.out.println("num1 = " + num1);
		

		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}

		System.out.println("num2 = " + num2);

		// 区分：| 与 || 
		//相同点1：| 与  || 的运算结果相同
		//相同点2：当符号左边是false时，二者都会执行符号右边的运算
		//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
		//开发中，推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num3 = " + num3);


		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num4 = " + num4);
	}
}
1.5 位运算符 （了解）

结论：

  1. 位运算符操作的都是整型的数据
  2. << ：在一定范围内，每向左移1位，相当于 * 2
    >> :在一定范围内，每向右移1位，相当于 / 2

面试题： 最高效方式的计算2 * 8 ？ 2 << 3 或 8 << 1

class BitTest {
	public static void main(String[] args) {
		int i = 21;
		i = -21;
		System.out.println("i << 2 :" + (i << 2));
		System.out.println("i << 3 :" + (i << 3));
		System.out.println("i << 27 :" + (i << 27));

		int m = 12;
		int n = 5;
		System.out.println("m & n :" + (m & n));
		System.out.println("m | n :" + (m | n));
		System.out.println("m ^ n :" + (m ^ n));

		//练习：交换两个变量的值
		int num1 = 10;
		int num2 = 20;
		System.out.println("num1 = " + num1 + ",num2 = " + num2);

		//方式一：定义临时变量的方式
		//推荐的方式
		int temp = num1;
		num1 = num2;
		num2 = temp;

		//方式二：好处：不用定义临时变量  
		//弊端：① 相加操作可能超出存储范围 ② 有局限性：只能适用于数值类型
		//num1 = num1 + num2;
		//num2 = num1 - num2;
		//num1 = num1 - num2;

		//方式三：使用位运算符
		//有局限性：只能适用于数值类型
		//num1 = num1 ^ num2;
		//num2 = num1 ^ num2;
		//num1 = num1 ^ num2;

		System.out.println("num1 = " + num1 + ",num2 = " + num2);

	}
}
1.5 三元运算符

1.结构： (条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
如果表达式为true，则执行表达式1。
如果表达式为false，则执行表达式2。
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符可以嵌套使用

3. 凡是可以使用三元运算符的地方，都可以改写为if-else
反之，不成立。
4. 如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。

class SanYuanTest {
	public static void main(String[] args) {
		
		//获取两个整数的较大值
		int m = 12;
		int n = 5;

		int max = (m > n)? m : n;
		System.out.println(max);

		double num = (m > n)? 2 : 1.0;

		//(m > n)? 2 : "n大";//编译错误

		//**************************
		n = 12;
		String maxStr = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
		System.out.println(maxStr);

		//*****************************
		//获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;
		
		int max1 = (n1 > n2)? n1 : n2;
		int max2 = (max1 > n3)? max1 : n3;
		System.out.println("三个数中的最大值为：" + max2);

		//不建议
		//int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
		System.out.println("三个数中的最大值为：" + max3);

		//该写成if-else:
		if(m > n){
			System.out.println(m);
		}else{
			System.out.println(n);
		}
	}
}

2.分支结构中的if-else（条件判断结构）

一、三种结构

第一种：
if(条件表达式){
执行表达式
}

第二种：二选一
if(条件表达式){
执行表达式1
}else{
执行表达式2
}

第三种：n选一
if(条件表达式){
执行表达式1
}else if(条件表达式){
执行表达式2
}else if(条件表达式){
执行表达式3
}
…
else{
执行表达式n
}

Day04

1.If - else(补充)

说明：

  1. else 结构是可选的（就近原则）。
  2. 针对于条件表达式：
    > 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
    > 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
    > 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
  3. if-else结构是可以相互嵌套的。
  4. 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。

//random的简单使用

		int value = (int)(Math.random() * 90 + 10);// [0.0,1.0) --> [0.0,90.0) --->[10.0, 100.0) -->[10,99]
		System.out.println(value);
		//公式：[a,b]  :  (int)(Math.random() * (b - a + 1) )+ a

//一道例题，注意equals

/*
大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：
高：180cm以上；富：财富1千万以上；帅：是。
如果这三个条件同时满足，则：“我一定要嫁给他!!!”
如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
如果三个条件都不满足，则：“不嫁！”

*/

import java.util.Scanner;

class IfExer1 {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入你的身高：(cm)");
		int height = scan.nextInt();
		System.out.println("请输入你的财富：(千万)");
		double wealth = scan.nextDouble();

		/*
		方式一：
		System.out.println("请输入你是否帅：(true/false)");
		boolean isHandsome = scan.nextBoolean();

		if(height >= 180 && wealth >= 1 && isHandsome){
			System.out.println("我一定要嫁给他!!!");
		}else if(height >= 180 || wealth >= 1 || isHandsome){
			System.out.println("嫁吧，比上不足，比下有余。");
		}else{
			System.out.println("不嫁！");
		}
		*/

		//方式二：
		System.out.println("请输入你是否帅：(是/否)");
		String isHandsome = scan.next();

		
		if(height >= 180 && wealth >= 1 && isHandsome.equals("是")){ //注意这里
			System.out.println("我一定要嫁给他!!!");
		}else if(height >= 180 || wealth >= 1 || isHandsome.equals("是")){//和这里
			System.out.println("嫁吧，比上不足，比下有余。");
		}else{
			System.out.println("不嫁！");
		}
	}
}

2.分支结构中的 switch-case

1.格式
switch(表达式){
case 常量1:
执行语句1;
//break;

case 常量2:
执行语句2;
//break;

…

default:
执行语句n;
//break;

}

2.说明：
① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构
末尾结束为止。

② break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构

③ switch结构中的表达式，只能是如下的6种数据类型之一：
byte 、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)

④ case 之后只能声明常量。不能声明范围。

⑤ break关键字是可选的。

⑥ default:相当于if-else结构中的else.
default结构是可选的，而且位置是灵活的。
⑦ 如果switch-case结构中的多个case的执行语句相同，则可以考虑进行合并。

  	//**************如下的两种情况都编译不通过*********************
  	//情况一
  	
  	boolean isHandsome = true;
  	switch(isHandsome){ //不支持布尔型
  	
  	case true:
  		System.out.println("我好帅啊~~~");
  		break;
  	case false:
  		System.out.println("我好丑啊~~~");
  		break;
  	default:
  		System.out.println("输入有误~~~");
  	}
  	
  	//情况二
  	
  	int age = 10;
  	switch(age){
  	case age > 18: //不能比大小
  		System.out.println("成年了");
  		break;
  	default:
  		System.out.println("未成年");
  	}

3.For循环结构

一、循环结构的4个要素
① 初始化条件
② 循环条件 —>是boolean类型
③ 循环体
④ 迭代条件

二、for循环的结构

for(①;②;④){
③
}

执行过程：① - ② - ③ - ④ - ② - ③ - ④ - … - ②

		for(int i = 1;i <= 5;i++){//i:1,2,3,4,5
			System.out.println("Hello World!");
		}
		// i:在for循环内有效。出了for循环就失效了。

4.感想

希望能通过慢慢的练习，不断强化记忆，达到熟练程度。

5.补充点

如何从键盘获取不同类型的变量：需要使用Scanner类

具体实现步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化:Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法（next() / nextXxx()），来获取指定类型的变量

注意：
需要根据相应的方法，来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException
导致程序终止。

//1.导包：import java.util.Scanner;
import java.util.Scanner;

class ScannerTest{
	
	public static void main(String[] args){
		//2.Scanner的实例化
		Scanner scan = new Scanner(System.in);
		
		//3.调用Scanner类的相关方法
		System.out.println("请输入你的姓名：");
		String name = scan.next();
		System.out.println(name);

		System.out.println("请输入你的芳龄：");
		int age = scan.nextInt();
		System.out.println(age);

		System.out.println("请输入你的体重：");
		double weight = scan.nextDouble();
		System.out.println(weight);

		System.out.println("你是否相中我了呢？(true/false)");
		boolean isLove = scan.nextBoolean();
		System.out.println(isLove);

		//对于char型的获取，Scanner没有提供相关的方法。只能获取一个字符串
		System.out.println("请输入你的性别：(男/女)");
		String gender = scan.next();//"男"
		char genderChar = gender.charAt(0);//获取索引为0位置上的字符
		System.out.println(genderChar);
		

	}

}

Day05

1.While 循环的使用

一、循环结构的4个要素
① 初始化条件
② 循环条件 —>是boolean类型
③ 循环体
④ 迭代条件

二、while循环的结构

①
while(②){
③;
④;
}

**执行过程：**① - ② - ③ - ④ - ② - ③ - ④ - … - ②

说明：
1.写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的！
区别：for循环和while循环的初始化条件部分的作用范围不同。

**算法：**有限性。

2.do-while循环的使用

一、循环结构的4个要素
① 初始化条件
② 循环条件 —>是boolean类型
③ 循环体
④ 迭代条件

二、do-while循环结构：

①
do{
③;
④;

}while(②);

**执行过程：**① - ③ - ④ - ② - ③ - ④ - … - ②

说明：
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while更多一些。较少使用do-while
3. 不在循环条件部分限制次数的结构：for(;😉 或 while(true)
4. 结束循环有几种方式？
方式一：循环条件部分返回false
方式二：在循环体中，执行break

break关键字的使用： 一旦在循环中执行到break，就跳出循环

3.探究质数求法（要回顾）

问题1：
100以内的所有质数的输出。
质数：素数，只能被1和它本身整除的自然数。–>从2开始，到这个数-1结束为止，都不能被这个数本身整除。

最小的质数是：2

class PrimeNumberTest {
	public static void main(String[] args) {
		
		boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值

		for(int i = 2;i <= 100;i++){//遍历100以内的自然数
			
		
			for(int j = 2;j < i;j++){//j:被i去除
				
				if(i % j == 0){ //i被j除尽
					isFlag = false;
				}
				
			}
			//
			if(isFlag == true){
				System.out.println(i);
			}
			//重置isFlag
			isFlag = true;
		
		}
	}
}

问题2：
100000以内的所有质数的输出。实现方式一
质数：素数，只能被1和它本身整除的自然数。–>从2开始，到这个数-1结束为止，都不能被这个数本身整除。

对问题1中质数输出问题的优化

class PrimeNumberTest1 {
	public static void main(String[] args) {
		
		boolean isFlag = true;//标识i是否被j除尽，一旦除尽，修改其值
		int count = 0;//记录质数的个数

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long start = System.currentTimeMillis();

		for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
			
			//优化二：对本身是质数的自然数是有效的。
			//for(int j = 2;j < i;j++){
			for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
				
				if(i % j == 0){ //i被j除尽
					isFlag = false;
					break;//优化一：只对本身非质数的自然数是有效的。
				}
				
			}
			//
			if(isFlag == true){
				//System.out.println(i);
				count++;
			}
			//重置isFlag
			isFlag = true;
		
		}

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13

	}
}

问题3：(推荐的解决办法)
100000以内的所有质数的输出。实现方式二
质数：素数，只能被1和它本身整除的自然数。–>从2开始，到这个数-1结束为止，都不能被这个数本身整除。

对问题2的质数输出问题的优化

class PrimeNumberTest2 {
	public static void main(String[] args) {
		
		
		int count = 0;//记录质数的个数

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long start = System.currentTimeMillis();

		label:for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
			
			for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
				
				if(i % j == 0){ //i被j除尽
					continue label;
				}
				
			}
			//能执行到此步骤的，都是质数
			count++;
		
		}

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("所花费的时间为：" + (end - start));//17110 - 优化一：break:1546 - 优化二：13

	}
}

4.break和continue关键字的使用

关键字使用范围循环中使用的作用(不同点)相同点
breakswitch-case
循环结构中结束当前循环关键字后面不能声明执行语句
continue循环结构中结束当次循环关键字后面不能声明执行语句

Note:(标签的使用)

label:for(int i = 1;i <= 4;i++){
		
			for(int j = 1;j <= 10;j++){
				
				if(j % 4 == 0){
					//break;//默认跳出包裹此关键字最近的一层循环。
					//continue;

					//break label;//结束指定标识的一层循环结构
					continue label;//结束指定标识的一层循环结构当次循环
				}
```
## Day06
### 1.数组
**一、数组的概述**
**1.数组的理解：**数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，
 * 并通过编号的方式对这些数据进行统一管理。

**2.数组相关的概念：** 
 * >数组名
 * >元素
 * >角标、下标、索引
 * >数组的长度：元素的个数

**3.数组的特点：**
 * 1）数组是有序排列的
 * 2）数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
 * 3）创建数组对象会在内存中开辟一整块连续的空间
 * 4）数组的长度一旦确定，就不能修改。

  **4. 数组的分类：**
 *   ① 按照维数：一维数组、二维数组、。。。
 *   ② 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组
 
#### 1.1一维数组的使用
 *   ① 一维数组的声明和初始化
 *   ② 如何调用数组的指定位置的元素
 *   ③ 如何获取数组的长度
 *   ④ 如何遍历数组
 *   ⑤ 数组元素的默认初始化值 ：见ArrayTest1.java
 *   ⑥ 数组的内存解析 ：见ArrayTest1.java

```java
public class ArrayTest {
    public static void main(String[] args) {
    
        //1. 一维数组的声明和初始化
        int <u>num</u>;//声明
        num = 10;//初始化
        int <u>id</u> = 1001;//声明 + 初始化
        int[] ids;//声明
        //1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
        ids = new int[]{1001,1002,1003,1004};
        //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
        String[] names = new String[5];
        //错误的写法：

//      int [] arr1 = new int[];
//      int[5] arr2 = new int[5];
//      int[] arr3 = new int[3]{1,2,3};  
        //也是正确的写法：
        int[] <u>arr4</u> = {1,2,3,4,5};//类型推断
        //总结：数组一旦初始化完成，其长度就确定了。
        //2.如何调用数组的指定位置的元素:通过角标的方式调用。
        //数组的角标（或索引）从0开始的，到数组的长度-1结束。
        names[0] = "王铭";
        names[1] = "王赫";
        names[2] = "张学良";
        names[3] = "孙居龙";
        names[4] = "王宏志";//charAt(0)

//      names[5] = "周扬";
        //3.如何获取数组的长度。
        //属性:length
        System.out.println(names.length);//5
        System.out.println(ids.length);
        //4.如何遍历数组
        /*System.out.println(names[0]);
        System.out.println(names[1]);
        System.out.println(names[2]);
        System.out.println(names[3]);
        System.out.println(names[4]);*/
        for(int i = 0;i < names.length;i++){

            System.out.println(names[i]);

        }
    }
}


```

 * ⑤ 数组元素的默认初始化值
 *      > 数组元素是整型：0
 *      > 数组元素是浮点型：0.0
 *      > 数组元素是char型：0或'\u0000'，而非'0'
 *      > 数组元素是boolean型：false
 *      > 数组元素是引用数据类型：null
 * ⑥ 数组的内存解析



#### 1.2二维数组的使用

  **1.理解：**
 * 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
 * 其实，从数组底层的运行机制来看，其实没有多维数组。
 **2. 二维数组的使用:**

 *   ① 二维数组的声明和初始化
 *   ② 如何调用数组的指定位置的元素
 *   ③ 如何获取数组的长度
 *   ④ 如何遍历数组
 *   ⑤ 数组元素的默认初始化值 :见 ArrayTest3.java
 *   ⑥ 数组的内存解析 :见 ArrayTest3.java
 
```java
public class ArrayTest2 {
    public static void main(String[] args) {
        //1.二维数组的声明和初始化
        int[] <u>arr</u> = new int[]{1,2,3};//一维数组
        //静态初始化
        int[][] arr1 = new 
        int[][]{{1,2,3},{4,5},{6,7,8}};
        //动态初始化1
        String[][] arr2 = new String[3][2];
        //动态初始化2
        String[][] arr3 = new String[3][];
        //错误的情况 
//      String[][] arr4 = new String[][4];
//      String[4][3] arr5 = new String[][];
//      <u>int</u>[][] arr6 = new 
        int[4][3]{{1,2,3},{4,5},{6,7,8}};

        //也是正确的写法：
        int[] arr4[] = new 
        int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
        int[] <u>arr5</u>[] = {{1,2,3},{4,5},{6,7,8}};
      //2.如何调用数组的指定位置的元素

        System.out.println(arr1[0][1]);//2
        System.out.println(arr2[1][1]);//null
        arr3[1] = new String[4];
        System.out.println(arr3[1][0]);
        //3.获取数组的长度

        System.out.println(arr4.length);//3
        System.out.println(arr4[0].length);//3
        System.out.println(arr4[1].length);//4

        //4.如何遍历二维数组
        for(int i = 0;i < arr4.length;i++){
            for(int j = 0;j < 
arr4[i].length;j++){
                System.out.print(arr4[i][j] + "  ");
            }
            System.out.println();
        }    
    }
}

```


**规定：** 二维数组分为外层数组的元素，内层数组的元素

 *      int[][] <u>arr = new int[4][3];

 *      外层元素：arr[0],arr[1]等

 *      内层元素：arr[0][0],arr[1][2]等

 * 

 *   ⑤ 数组元素的默认初始化值 

 *   针对于初始化方式一：比如：int[][] arr = new 
    int[4][3];

 *      外层元素的初始化值为：地址值
 *      内层元素的初始化值为：与一维数组初始化情况相同
 *      
 *   针对于初始化方式二：比如：int[][] arr = new 
int[4][];
 *       外层元素的初始化值为：null
 *      内层元素的初始化值为：不能调用，否则报错。
 *   
 *   ⑥ 数组的内存解析 
 * 

```java
public class ArrayTest3 {
    public static void main(String[] args) {
        int[][] arr = new int[4][3];
        System.out.println(arr[0]);//[I@15db9742 
        System.out.println(arr[0][0]);//0

//      System.out.println(<u>arr</u>);//[[I@6d06d69c
        System.out.println("*****************");
        float[][] arr1 = new float[4][3];
        System.out.println(arr1[0]);//地址值
        System.out.println(arr1[0][0]);//0.0

        System.out.println("*****************");
        String[][] arr2 = new String[4][2];
        System.out.println(arr2[1]);//地址值
        System.out.println(arr2[1][1]);//null
        System.out.println("*****************");
        double[][] arr3 = new double[4][];
        System.out.println(arr3[1]);//null
//      System.out.println(arr3[1][0]);//报错
 
    }
}
```
KayStart2020
关注
专栏目录
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
java基础学习笔记（非常全面）
01-04
主要是根据传智播客视频和百度上查的，这个是我（老delphi程序员）转java时做的学习笔记，第一遍学习时没有记笔记学完之后发现全忘记了，为了记笔记又学习了一遍。
《Java基础与案例开发详解》笔记（一）
venus321的博客
09-14 635
java基础总结与回顾
《Java基础教程案例》读书心得
adsdaas的博客
10-10 455
    建议新入门的Java程序猿观看，书籍里面共包含 11 章内容，涵盖了Java基础的全部知识，配备了 20 个任务案例，22到思考题。     这本书在我读完以后觉得还是挺不错的一本书，每章的知识点讲的还是挺详细的，最主要的还是你学过此章节的知识点后，在结尾处会有根据所讲解的内容提供一道案例题对知识点的理解进行加深，这一点还是很有必要的，学习每一门语言都要多敲多练熟能生巧，没有捷径可以走。 目录结构 第一章：Java开发
Java基础与案例开发详解のjava语言基础入门
爱的叹息的专栏
06-26 959
变量是存储数据的基本单元，生活实例与变量之间的关系 变量的声明和赋值三部曲 变量的8种分类和转义字符 小知识和注意事项 普及二进制、八进制、十六进制以及之间的转换 基本数据类型之间的转换 变量命名规范 变量命名常见的三点错误的分析与处理 java标识符命名规则 关键字 常量 运算符种类 表达式优先级 条件语句种类
Java基础知识总结（2021版）
学Java，找哪吒
01-09 25万+
前言 大家好，我是素小暖，2012年毕业，2016年通过培训转行java开发，今天2021年1月9日，转行之路跌跌绊绊，蓦然回首，已经满满的4年工作经验了？但感觉知识还是相当的匮乏，没自信，也许是努力程度还不够吧。很感谢CSDN，因为是它给了我学习的动力，之前写了一篇记录CSDN博客访问量的文章，也许大家感觉很幼稚，但真的很有用，很有效果，仿佛磕了药一样，努力学习，进步。 2020年，是我较为成功的一年，工作上，跳了槽，涨了工资；学习上，啃了几本名著（Effective Java、重构 改善既.
Java学习路线总结，搬砖工逆袭Java架构师
学Java，找哪吒
09-07 25万+
定期分享Java硬核技术干货、分享Java学习路线、分享Java经典面试题
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7762
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
Java基础知识总结（超详细整理）
热门推荐
龙源IT 的博客
07-17 32万+
Java语言的特点，1.面向对象(OOP)就是Java语言的基础，也是Java语言的重要特性。面向对象的概念：生活中的一切事物都可以被称之为对象，生活中随处可见的事物就是一个对象，我们可以将这些事物的状态特征（属性）以及行为特征（方法）提取并出来，并以固定的形式表示。 2.简单好用，Java语言是由C和C++演变而来的，它省略了C语言中所有的难以理解、容易混淆的特性（比如指针），变得更加严谨、简洁、易使用。 3.健壮性、Java的安全检查机制，将许多程序中的错误扼杀在摇蓝之中。 另外，在
Java基础知识之笔记总结分享（超详细）
iswitched的博客
05-03 7万+
给大家分享一篇我在学习java过程中的关于java基础部分的笔记，包含面向对象思想，集合，接口，抽象方法等等详细知识点
Java学习笔记
Piglett的博客
12-30 1220
随着后续的学习还会不断地更新，并不仅仅包含Java基础，后续还会更新SSM，MySQL等内容。其记录了Java基础的学习内容，主要包括24集合到30动态代理（见语雀目录）。希望这篇笔记能够帮助到Java的学习，方便快速进行回顾复习。
Java基础知识笔记
qq_40004487的博客
03-12 1556
Java基础笔记参考--狂神说、韩顺平。一定要多敲代码！多敲代码！多敲代码！
Java基础尚硅谷宋红康学习笔记
05-29
【Java基础】 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）于1995年发布。Java以其“一次编写，到处运行”的特性，成为跨平台应用开发的首选语言。Java的基础部分主要包括...
java基础总结大全(笔记).pdf
02-28
Java基础总结大全涵盖了Java编程语言的核心概念，从JVM、JRE和JDK的区别，到环境变量的设置，再到变量的定义和类型转换，深入浅出地讲解了Java的基础知识。 1. JVM、JRE和JDK： - JVM（Java Virtual Machine）是...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 440
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 930
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
服务器虚拟化
Hellc007的博客
10-30 971
服务器虚拟化是一种将物理服务器的计算资源分割为多个独立虚拟环境的技术，通过软件层将底层硬件资源抽象化并在上层构建多个虚拟机（Virtual Machine, VM）。每个虚拟机运行独立的操作系统和应用程序，相互之间不受干扰，具备类似于物理服务器的功能。这种技术使得一台物理服务器能够承担多台虚拟服务器的角色，从而极大地提升了硬件资源的利用率。服务器虚拟化的概念最早可追溯到20世纪60年代IBM大型机时代，当时虚拟化被用来将大型机的资源分配给多个任务，使得企业在有限的资源下能够同时运行多个应用。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 978
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
Java基础学习笔记：从入门到精通
笔记可能存在少量错误，但整体上是一个全面的Java基础知识总结。 在Java编程语言中，`public class 文件名` 是定义一个公共类的方式，每个Java程序都至少有一个类。`public static void main(String[] args)` 是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值