Java学习笔记——基础知识（一）

最新推荐文章于 2024-08-10 16:13:20 发布
最新推荐文章于 2024-08-10 16:13:20 发布
阅读量182 收藏
点赞数
分类专栏： Java学习笔记 文章标签： java eclipse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ljqwe/article/details/119645581
版权

Java学习笔记——基础知识（一）

文章目录

前言

学习JAVA基础过程中随手记录的笔记，完全自用，代码都可以运行出来。基础只涉及到数组部分，后面的面向对象部分另起一篇来写。

下面开始啦~~~~希望自己可以坚持下去啊

一、Java体系

1、Java基础

  • 跨平台
  • 面向对象编程
  • 分布式计算

2、Java的运行机制

  • 编程java程序
  • 编译java文件
  • 读取字节码文件运行程序

java JVM虚拟机——>跨平台
自动的垃圾回收机制，但还是会存在内存溢出和内存泄漏的情况。

3、Java的三大体系

  • Java SE(J2SE)
  • Java ME(J2ME)
  • Java EE(J2EE)

4、配置环境

JRE、JDK
JRE：Java Runtime Environment Java 运行环境
JDK：Java Devlopment Kit Java 开发工具包

5、开发

  • 编译
javac HelloWorld.java
  • 运行
java HelloWorld

Java IDE
NetBeans、Eclipse、IDEA

Eclipse快捷键Alt+/
main输入main函数后，可以快速补全
syso补全输出语句
快捷指令描述
Ctrl+shift+F代码格式化

6、代码规范

  • 强制性代码规范，必须执行的
    1、Java 程序的文件名与类名必须一致，若不一致，无法通过编译。
    2、main 方法是程序的入口，方法的定义必须严格按照格式书写。
    3、类是组织 Java 代码结构的，类中的方法是执行具体业务的。

  • 非强制性代码规范，建议按照此方式编写代码
    1、一行只写一条语句。
    2、在 1 的基础上，还要注意代码缩进。

二、基本概念

1.安装Java环境

  • 编写Java代码
  • 编译Java代码，成为字节码文件 16进制
    javac 文件名（带后缀）
  • 让JVM执行字节码文件，运行程序
  • java文件名（不带后缀）

IDE：集成开发环境
Eclipse、IDEA

2、注释

注释就是用通俗易懂的语言对代码进行描述解释，方便自己和他人阅读。

  • 单行注释
//注释内容
  • 多行注释
/*注释内容
注释内容
注释内容
*/
  • 文档注释（输入/**之后按回车键可以自动生成文档注释格式）
/*注释内容
*注释内容
*注释内容
*/

3、关键字

Java语言预先定义好的、有指定意义的标识符，组成程序的基本元素。

关键字描述
abstract抽象（函数/类）
boolean基本数据类型
break跳出循环
byte基本数据类型
case与switch搭配使用
catch与try搭配使用，表示捕获已查过
class表示一个类
enum枚举类型
extends继承
final修饰常量
implements实现接口
native表示本地方法
new创建对象
private私有
public公共
super父类
static表示静态
synchronized线程同步
this表示当前实例
throw抛出异常
throws方法中主动抛出异常
void表示方法没有返回值
volatile表示线程读取到最新值

4、变量

  • 数据类型
  • 变量名
  • 变量值

变量的分类

在这里插入图片描述
在这里插入图片描述

5、使用变量

  1. 声明变量的数据类型和变量名（包含数字、字母、下划线、$，不能包含空格、运算符，不能用关键字命名，不能以数字开头），大小写可以混用，首单词应该小写，后续单词的首字母大写
    userId、studentName（驼峰式命名）

  2. 给内存空间赋值，该值就是变量值

6、Java的数据类型

  • 基本数据类型
    byte, int, short, long, float, double, char, boolean
    数值类型（整数，小数）
    byte 1个字节（8位）（1B KB MB GB TB）
    int 4个字节（32位）
    short 2个字节（16位）
    long 8个字节（64位）
    float 4个字节（32位）单精度浮点型
    double 8个字节（64位）双精度浮点型
    非数值类型（文本）
    char 字符 2个字节（16位）
    boolean 1/8个字节，判断逻辑是否成立 true/false
  • 引用数据类型

7、数据类型转换

  • 自动转换
    Java可以自动对某些数据类型进行自动转换
    规则：只能由低字节向高字节转换，反之则不行
    byte->int-> short-> long-> float-> double
  • 强制类型转换
    Java无法自动转换的数据类型，开发者可以通过强制手段进行转换
    一般来讲强制类型转换可能会造成精度损失。
double num = 10.0;
int num2 = (int) num;

8、String类型变量

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

9、运算符

  • 赋值运算符
    数据类型 变量名 = 数值/变量

  • 算术运算符
    （1）基本算术运算符
    +、-、 、 /、++ 、 –
    变量1/变量2 两边都是整型结果才是整型，否则是浮点型
    变量++、++变量 （变量=变量+1）
    变量–、--变量（变量=变量-1 ）
    变量++：先操作，再运算
    ++变量 ：先运算，再操作
    （2）复合算数运算符
    +=、-=、    =、/=、%=
    变量1+=变量2：先求出变量1和变量2的和，再把计算结果赋值给变量1
    ，变量1=变量1+变量2

  • 关系运算符
    ==、!=、>、<、>=、=<

  • 逻辑运算符
    逻辑运算符只能用于boolean类型的数据运算，判断boolean数据之间的逻辑关系 ，与、或、非
    &（与）、|（或）、！（非）、&&（短路与）、||（短路或）
    参与逻辑运算符的变量都是boolean类型的
    变量1 & 变量2：只有当变量1和变量2都为true，结果为true，否则为false
    变量1 | 变量2：变量1和变量2只要有1个为true，结果为true，否则为false
    ！变量1：若变量1为true，结果为false，若变量1位false，结果为true
    变量1 && 变量2：只有当变量1和变量2都为true，结果为true，否则为false
    变量1 || 变量2：变量1和变量2只要有一个为true，结果为true，否则为false
    （后面两条在变量1结果已知的情况下可以省略变量2 的运算，可以节约时间？）

  • 条件运算符
    三元运算符、三目运算符、三元表达式
    根据不同的条件给同一个变量赋不同的值，变量=条件？值1：值2；

  • 位运算符
    a、十进制和二进制的转换
    十进制转二进制：目标数除以2，若能除尽，该位记为0，若除不尽，该位记为1，再对商继续除以2，以此类推，直到商为0，然后把每一位的结果反序组合就是对应的二进制。
    10:1010
    17:10001
    二进制转十进制：从目标数的最后侧开始，本位的数值乘以本位的权重，权重就是2的第几位的位数减一次方，将每一位的值进行相加，得到的结果就是十进制。
    1010：10
    b、位运算符：&（按位与）、|（按位或）、^（按位异或）、<<（左移）、>>（右移）
    变量1 & 变量2：先把变量1和变量2转为二进制，每一位的数字一一对应，进行比较判断，若都为1，则该位记做1，否则记做0。
    变量1 | 变量2：先把变量1和变量2转为二进制，每一位的数字一一对应，进行比较判断，只要有一个位1，则该位记做1，否则记做0。
    变量1 ^ 变量2：先把变量1和变量2转为二进制，每一位的数字一一对应，进行比较判断，若相同，则该位记做0，否则记做1。
    变量1 << 变量2：变量1乘以2的变量2次方
    2<<3:2*8=16
    变量1 >> 变量2：变量1乘以2的变量2次方
    2>>3:2/8=0

  • 运算符的优先级
    ！>算数运算符>关系运算符>逻辑运算符（&&>||）

10、流程控制

break和continue关键字的使用

break：switch-case，循环结构中；结束当前循环
continue：循环结构中；结束当次循环

带有标签的break和continue关键字的使用
public class Test20 {
	public static void main(String[] args) {
		label:for (int i = 1; i <= 4; i++) {
			for (int j = 1; j <= 10; j++) {
				if (j % 4 == 0) {
					//break;//默认跳出包裹此关键字最近的一层循环
					//continue;
					
					//break label;//结束指定label标识的一层循环结构
					continue label;//结束指定label标识的一层循环结构的当次循环
				}
				System.out.print(j);
			}
			System.out.println();
		}
	}
}

scanner

如何从键盘获取不同类型的变量？—》使用scanner类
具体实现步骤：
1.导包：import java.util.Scanner;
2.Scanner的实例化：Scanner scan= new Scanner(System.in);
3.调用Scanner类的相关方法（.next数据类型），来获取指定类型的变量
对于char类型的获取，Scanner没有提供相关的方法，只能获取一个字符串

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

if else

用来判断某个条件是否成成立，然后执行不同的逻辑运算
基本语法：

if（判断条件）{
	//条件成立的代码
}
else{
	//条件不成立的代码
}
  • 多重if
    173M
    173~178L
    178XL
public class Test3 {
	public static void main(String[] args) {
		int height = 180;
		if (height < 173) {
			System.out.println("M码");
		} else if (height >= 173 && height <= 178) {
			System.out.println("L码");
		} else if (height > 178) {
			System.out.println("XL码");
		}
	}
}

1.if后面跟条件
2.else后面不能跟条件
3.else后面可以跟{}，也可以跟if

  • switch-case
    与if不同的是，switch-case只能完成等值判断，而无法完成判断大小
    如果是判断两个值是否相等，可以使用switch-case，如果比较两个值的大小关系，则不能使用switch-case。
    switch支持int、short、byte、char、枚举、String类型，不支持boolean类型。
    基本语法：
switch（变量）{
	case 值1:
		// 业务代码
		break;
	case 值2:
		// 业务代码
		break;
	...
	default:
		// 业务代码
		break;
}

示例：

·跑步比赛：1奖励2000元   2奖励1000元   3奖励500元  否则没有奖励
public class Test4 {
	public static void main(String[] args) {
		int rank = 1;
		switch (rank) {
		case 1:
			System.out.println("奖励2000元！");
			break;
		case 2:
			System.out.println("奖励1000元!");
			break;
		case 3:
			System.out.println("奖励500元!");
			break;
		default:
			System.out.println("没有奖励!");
			break;
		}
	}
}

case是用来判断是否等于某个值，default表示所有的case都不成立的情况下所执行的代码。

循环

for、while、do-while、foreach
循环四要素：

  • 初始化循环变量
  • 循环条件
  • 循环体
  • 更新循环变量
初始化循环变量；
while（循环条件）{
	循环体；
	更新循环条件；
}

示例（学生成绩管理系统查询成绩）：

import java.util.Scanner;

public class Test5 {
	public static void main(String[] args) {
		int num = 0;
		String flag="y";
		while (flag.equals("y")) {
			System.out.print("请输入学生学号：");
			Scanner scanner = new Scanner(System.in);
			int id = scanner.nextInt();
			// scanner.next() 可以接收字符串，具体根据要输入的内容选择相应的scanner.
			System.out.println("用户输入的学号是" + id);
			switch (id) {
			case 1:
				System.out.println("张三的成绩是96");
				break;
			case 2:
				System.out.println("李四的成绩是91");
				break;
			case 3:
				System.out.println("王五的成绩是89");
				break;
			default:
				System.out.println("请输入正确的学号");
				break;
			}
			System.out.print("是否继续？y/n");
			flag = scanner.next();
		}
		System.out.println("感谢使用学生查询系统！");
	}
}

 - do-while循环

```java
public class Test6 {
	public static void main(String[] args) {
		// 创建循环变量
		int num = 0;
		do {
			// 循环体
			System.out.println("hello world");
			// 更新循环变量
			num++;
		} while (num < 10);
		// 循环条件
	}
}

示例：

import java.util.Scanner;

public class Test7 {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String result = "";
		do {
			System.out.println("张三参加体能测试，跑1000米");
			System.out.print("是否合格？y/n");
			result = scanner.next();
		} while (result.equals("n"));
		System.out.println("合格,通过测试");
	}
}
  • for循环
for (初始化循环变量;循环条件;更新循环变量）{
		循环体;
}

while , do-while ,for 3中循环的区别：

  • 相同点：都遵循循环四要素，初始化循环变量、循环条件、循环体、更新循环变量
  • 不同点：
    1.while和do-while适用于循环次数不确定的业务场景；for适用于循环次数确定的场景。
    2.while和for都是先判断循环条件，再执行循环体；do-while先执行循环体，再判断循环条件。

示例：分别使用while、do-while、foe循环输出10以内的所有奇数。

import java.util.Iterator;

public class Test10 {
	public static void main(String[] args) {
		// while循环
		int num = 0;
		while (num<=10) {
			if(num%2!=0) {
				System.out.println(num);
				num++;
			}
		}
		// do-while循环
		int num = 0;
		do {
			if (num % 2 != 0) {
				System.out.println(num);
			}
			num++;
		} while (num<=10);

		// for循环
		for (int num = 0; num <= 10; num++) {
			if (num % 2 != 0) {
				System.out.println(num);
			}
		}

	}

}

！for循环只适用于循环次数确定的场景下（for也可以适用于循环次数不确定的场景，只不过一般不会用这种方式），while和do-while循环次数确定或者不确定的场景都可以使用

嵌套循环的使用

1.嵌套循环：将一个循环结构A声明在另一个循环结构B 的循环体中，就构成了嵌套循环。
2.外层循环：循环结构B
内层循环：循环结构A

示例：100以内的所有质数的输出
/*
 100以内的所有质数的输出
 质数：素数，只能被1和它本身整除的自然数。--->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
 */
public class Test19 {
	public static void main(String[] args) {
		for (int i = 2; i <= 100; i++) { // 遍历100以内的自然数
			boolean isFlag = true; // 标识i是否被j除尽，一旦除尽，修改其值
			for (int j = 2; j < i; j++) { // j:被i整除
				if (i % j == 0) { // i被j除尽
					isFlag = false;
				}
			}
			//
			if (isFlag) {
				System.out.println(i);
			}
		}
	}
}
对上面的优化（100以内所有质数）
/*
 100以内的所有质数的输出
 质数：素数，只能被1和它本身整除的自然数。--->从2开始，到这个数-1结束为止，都不能被这个数本身整除。
 */
public class Test19 {
	public static void main(String[] args) {
		// 获取当前时间距离1970年1月1日00:00的毫秒数
		int count = 0;
		long start = System.currentTimeMillis();
		for (int i = 2; i <= 100000; i++) { // 遍历100以内的自然数
			boolean isFlag = true; // 标识i是否被j除尽，一旦除尽，修改其值
			// 优化2：对本身只质数的自然数是有效的
			for (int j = 2; j < Math.sqrt(i); j++) { // j:被i整除
				if (i % j == 0) { // i被j除尽
					isFlag = false;
					break;// 优化1：只对本身非质数的自然数是有效的
				}
			}
			//
			if (isFlag) {
				System.out.println(i);
				count++;
			}
		}
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为："+count);
		System.out.println("所花费的时间为：" + (end - start));// 23152 //优化1：break----1948 优化2:124
	}
}

三、数组

数组的理解:数组（Array），是多个相同类型数据按照一定顺序排列的组合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

数组的基本要素

  • 数组名称
  • 数组元素
  • 元素下标（索引，从0开始）
  • 数据类型
  • 数组的长度：元素的个数
// 声明数组
int[] array;
// 分配内存空间
array = new int[6];
// 给数组赋值	
array[2] = 6;

// 边声明边赋值
int[] array1 = { 1, 2, 3, 4, 5, 6 };
int[] array2 = new int[] { 1, 2, 3, 4, 5, 6 };

数组的特点

  1. 数组本身就是一个变量，数组名称就是变量名，数组中保存的每一个数据都会有一个下标（从0开始）
  2. 数组是有序排列的
  3. 数组属于引用数据类型的变量。数组的元素，既可以是基本数据类型，也可以是引用数据类型
  4. 创建数组对象会在内存中开辟一整块连续的空间
  5. 数组的长度一旦确定，就不能修改

数组的分类

  1. 按照维数：一维数组、二维数组…
  2. 按照数组元素的类型：基本数据类型元素的数组、引用数据类型元素的数组

一维数组的使用

  1. 一维数组的声明和初始化
  2. 如何调用数组的指定位置的元素
  3. 如何获取数组的长度
  4. 如何遍历数组
  5. 数组元素的默认初始化值
  6. 数组的内存解析
    内存的简化结构
    一维数组的内存解析
/**
 * 
 */
package com.atguigu.contact;

/**
 * @Description
 * @author lj
 * @date 2021年8月26日下午7:10:18
 */
public class ArrayTest {

	public static void main(String[] args) {
		// 1.一维数组的声明和初始化
		int[] ids;// 声明
		// 1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
		ids = new int[] { 1001, 1002, 1003 };
		// 1.2 动态初始化:数组的初始化和数组元素的赋值操作分开进行
		String[] names = new String[5];
		//总结：数组一旦初始化完成，其长度就确定了。
		
		//2.如何调用数组的指定位置的元素：通过下标的方式调用
		//数组的角标（或索引）从0开始，到数组的长度-1结束
		names[0]="小明";
		names[1]="小陈";
		names[2]="小李";
		names[3]="小王";
		names[4]="小高";
		
		//3.如何获取数组的长度
		//属性：length
		System.out.println(names.length);//5
		
		//4.如何遍历数组
		for (int j = 0; j < names.length; j++) {
			System.out.println(names[j]);
		}
		
		//5.数组元素的默认初始化值
		//数组元素是整型（int,short,long,byte）：0
		//数组元素是浮点型（float，double）：0.0
		//数据元素是char型：0（阿斯科马值）或'\u0000'，而非'0'
		//数组元素是布尔型：false
		
		//数组元素是引用数据类型：null 
		int[] arr=new int[4];
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
}

数组常见的错误

  • 数据类型不匹配
  • 边声明边赋值的方式，代码必须写在同一行，不能换行
  • 数组下标越界

示例：Arrays的部分常用方法

public class Test14 {
	public static void main(String[] args) {
			int[] array1 = { 73, 80, 62, 93, 96, 87 };
			int[] array2 = { 73, 80, 62, 93, 96, 87 };
			int[] array3 = { 93, 96, 87 };
			// 判断两个数组是否相等
			System.out.println(Arrays.equals(array1, array2));
			//对数组进行排序
			Arrays.sort(array1);
			System.out.println(Arrays.toString(array1));
			//填充数组，把数组里的元素全部覆盖为一样的值
			Arrays.fill(array3, 555);
			System.out.println(Arrays.toString(array3));
			//复制数组array3且长度为10，如果长度超过原array3的话用0补上，如果长度不够的话，只取前几位即可
			int[] copyArray = Arrays.copyOf(array3, 5);
			System.out.println(Arrays.toString(copyArray));  //注意：Arrays.toString()只能对一维数组进行操作，二维数组的话只能返回内存地址
			//二分查找法要求数组必须有序，否则可能会查不到，查找87在数组中的下标，并返回(因为上面对array1进行过排序的操作，所以返回值是3)
//			Arrays.binarySearch(array1, 87);
			System.out.println(Arrays.binarySearch(array1, 87));
	}
}

多维数组

二维数组的使用

对于二维数组的理解，可以看成是以为数组array1又作为另一个一维数组array2的元素儿存在。其实，从数组底层的运行机制来看，其实没有多维数组。

  1. 二维数组的声明和初始化
  2. 如何调用数组的指定位置的元素
  3. 如何获取数组的长度
  4. 如何遍历数组
  5. 数组元素的默认初始化值
    针对初始化方式一：int[][] arr=new int[4][3];
    外层元素的初始化值：地址值
    内层元素的初始化值：与一维数组初始化情况相同
    针对初始化方式二：int[][] arr=new int[4][];
    外层元素的初始化值：null
    内层元素的初始化值：不能调用，否则报错。
  6. 数组的内存解析
    二维数组的内存解析
代码示例
package com.atguigu.contact;

public class ArrayTest2 {
	public static void main(String[] args) {
		// 1. 二维数组的声明和初始化
		// 静态初始化
		int[][] arr1 = new int[][] { { 1, 2, 3 }, { 4, 5 }, { 7, 8, 9 } };
		// 动态初始化1
		String[][] arr2 = new String[3][2];
		// 动态初始化2
		String[][] arr3 = new String[3][];
		// 也是正确的写法
		int[][] arr4 = new int[][] { { 1, 2, 3 }, { 4, 5 }, { 7, 8, 9 } };
		// 或者
		int[][] arr5 = { { 1, 2, 3 }, { 4, 5 }, { 7, 8, 9 } };
		// 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[1].length);// 2
		// 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();
		}
		// 5. 数组元素的默认初始化值
		// 规定：二维数组分为外层数组的元素，内层数组的元素
		// int[][] arr = new int[4][3];
		// 外层元素：arr[0],arr[1]等
		// 内层元素：arr[0][1],arr[1][2]等
		int[][] arr = new int[4][3];
		System.out.println(arr[0]);// [I@156643d4地址值
		System.out.println(arr[0][0]);// 0
		System.out.println(arr);// [[I@123a439b

		double[][] arr6 = new double[4][2];
		System.out.println(arr6[1]);// null
		System.out.println(arr6[1][0]);// 报错：空指针异常
	}
}

Arrays工具类的使用

java.utils.Arrays：操作数组的工具类，里面定义了很多操作数组的方法
常用的方法

数组中的常见异常

  1. 数组角标越界的异常ArrayIndexOutOfBoundsException
  2. 空指针异常NullPointerException

四、数据结构

  1. 数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
  2. 数据的存储结构：
    线性表：顺序表（比如：数组）、链表、栈（先进后出）、队列（先进先出）
    树形结构：二叉树
    图形结构

算法：
搜索算法：

package com.atguigu.com;

import java.util.Iterator;

/**
 * 
 * @Description
 * @author lj
 * @date 2021年8月29日下午5:03:42
 */
public class ArrayTest2 {
	/**
	 * 算法的考查：数组的复制、反转、查找（线性查找、二分法查找）
	 */
	public static void main(String[] args) {
		String[] arr = new String[] { "JJ", "DD", "MM", "BB", "GG", "AA" };

		// 数组的复制（区别于数组变量的赋值：arr1=arr）
		String[] arr1 = new String[arr.length];
		for (int i = 0; i < arr.length; i++) {
			arr1[i] = arr[i];
		}

		// 数组的反转
		for (int i = 0; i < arr1.length / 2; i++) {
			String temp = arr[i];
			arr[i] = arr[arr.length - i - 1];
			arr[arr.length - i - 1] = temp;
		}

		// 遍历
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + "\t");
		}

		System.out.println();

//		// 尝试另一种写法？验证过了！是可以的！
		String[] array = new String[arr.length];
//		for (int i = 0; i < array.length; i++) {
//			for (int j = array.length-1; j >= 0; j--) {
//				array[i]=arr[j];
//			}
//		}
//		//遍历试一下
//		for (int i = 0; i < array.length; i++) {
//			System.out.print(arr[i]+"\t");
//		}

		// 上面注释部分的改良写法
		for (int i = 0, j = arr1.length - 1; i < j; i++, j--) {
			String temp = arr[i];
			arr[i] = arr[arr.length - i - 1];
			arr[arr.length - i - 1] = temp;
		}

		// 遍历试一下
		for (int i = 0; i < array.length; i++) {
			System.out.print(arr[i] + "\t");
		}

		System.out.println();

		// 查找（或搜索）
		// 线性查找
		String target = "BB";

		boolean isFlag = true;

		for (int i = 0; i < arr.length; i++) {

			if (target.equals(arr[i])) {
				System.out.println("找到了指定的元素，位置为：" + i);
				isFlag = false;
				break;
			}
		}
		if (isFlag) {
			System.out.println("很遗憾，没有找到");
		}

		// 二分法查找
		// 前提：所要查找的数组必须有序
		int[] arr2 = new int[] { -98, -34, 2, 34, 54, 66, 79, 105, 210, 333 };

		int target1 = 0;
		int head = 0;
		int end = arr2.length - 1;

		boolean isFlag1 = true;

		while (head <= end) {

			int middle = (head + end) / 2;

			if (target1 == arr2[middle]) {
				System.out.println("找到了指定的元素，位置为：" + middle);
				isFlag1 = false;
				break;
			} else if (arr2[middle] > target1) {
				end = middle - 1;
			} else {
				head = middle + 1;
			}
		}
		
		//p判断有没有进去上面的if循环语句（因为里面有个isFlag1 = false的语句）
		if (isFlag1) {
			System.out.println("没有找到相关元素");
		}
	}
}

排序算法:
十大内部排序算法：

  • 选择排序：直接选择排序、堆排序
  • 交换排序：冒泡排序、快速排序
  • 插入排序：直接插入排序、折半插入排序、shell排序
  • 归并排序
  • 桶式排序
  • 基数排序
package com.atguigu.com;

public class BubbleSort {
	public static void main(String[] args) {
		/**
		 * 数组的冒泡排序的实现
		 * 时间复杂度O(n^2)
		 */
		int[] array = new int[] { 43, 22, 56, -45, 26, 11, 56, 41, -53 };

		// 冒泡排序
		for (int i = 0; i < array.length - 1; i++) {
			for (int j = 0; j < array.length - 1 - i; j++) {

				if (array[j] > array[j + 1]) {
					int temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}

			}
		}
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i]+"\t");
		}
		
		/**
		 * 数组的快速排序的实现
		 * 时间复杂度：O（nlogn）
		 */
		//......
	}
}
吃布丁的胖丁
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java学习笔记——良葛格
06-12
"Java学习笔记——良葛格"是一份专为初学者设计的教程资料，由良葛格精心编写，旨在帮助读者掌握JDK5.0版本的Java基础知识。JDK（Java Development Kit）是Java开发的核心工具集，包含了编译器、调试器和运行环境等...
个人学习的java笔记——思维导图
01-25
这份"个人学习的java笔记——思维导图"涵盖了上述诸多Java编程的核心知识点，通过思维导图的方式，使得学习者可以更直观地理解和记忆这些复杂的概念，对提升Java学习效果大有裨益。无论你是初学者还是有经验的开发者...
JAVA学习笔记————————
04-25
在深入探讨JAVA学习笔记之前，我们首先理解一下JAVA这一编程语言的重要性。JAVA，由Sun Microsystems公司（现已被Oracle收购）于1995年推出，是一种面向对象的、跨平台的编程语言，以其“一次编写，到处运行”的特性...
狂神Java学习笔记————前端入门——html、css、JavaScript学习代码
06-17
【狂神Java学习笔记——前端入门——HTML、CSS、JavaScript学习代码】是针对初学者的一份详实的学习资料，这份笔记记录了跟随B站知名up主“遇见狂神说”的java系列视频中关于前端开发的基础内容。笔记内容不仅与视频...
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1242
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
C++ - 函数重载
jiaowenjie的专栏
08-06 327
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 211
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
Spring事务
c1tenj2的博客
08-07 435
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
反射和注解
supercool7的博客
08-08 254
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Java：继承，this，super
最新发布
m0_75257168的博客
08-10 276
可以同名，但参数列表不能相同（有参无参构造）
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 274
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
Spring一个强大便捷的代理工厂类
330553352的专栏
08-10 200
但如果你需要一种更加灵活和可配置性，那么Spring还提供了一个非常方便强大的ProxyFactoryBean类，该类特别适合那些需要更多自定义和控制的场景，例如当你需要为特定的Bean创建代理，或者需要在不修改原始代码的情况下为现有类添加额外的功能时。在Spring框架中，AOP（面向切面编程）是一种强大的编程范式，它允许开发者在不修改原有代码的情况下，为程序添加额外的功能，如日志记录、事务管理、安全控制等。在上面配置拦截器时，我们都是指定的具体拦截器，其实我们还可以使用通配符，指定拦截器。
JVM 加载阶段 Class对象加载位置是在 堆中还是方法区？
萧曳丶
08-06 376
Class对象的加载位置：Class对象本身是加载到堆区中的。类的类型信息加载位置：类的类型信息（元数据）是加载到方法区（或元空间）中的。因此，对于问题“jvm 加载阶段 Class加载到堆中还是方法区”，答案是：Class对象加载到堆中，而类的类型信息加载到方法区（或元空间）中。这两个区域在JVM的类加载过程中都扮演着重要的角色，共同支持着Java程序的运行。
log4j反序列化-流程分析
无
08-06 1128
JDK8u141依赖</</</</</</</</</
dynamic-datasource+Mybatis多数据源使用
tiantiantbtb的博客
08-06 895
严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源。#设置默认的数据源或者数据源组,默认值即为master。#去掉默认使用HikariCP。
javaImageIo实现图片内容动态修改
zhangzeshan
08-07 158
在指定坐标绘制水印文字
Leetcode JAVA刷刷站（10）正则表达式匹配
m0_73399576的博客
08-10 516
Leetcode JAVA刷刷站——字符串转换整数篇
mvn install:install-file命令
Simon_cm的博客
08-07 122
包路径,groupId,artifactId,版本,需要加英文"",否则可能会报错。-DgeneratePom=true：是否自动生成POM文件，默认为true。-DcreateChecksum=true：是否创建校验和文件，默认为true。-Dpackaging：打包方式，通常是 jar,war等。-DartifactId：通常是项目的构件id。-DgroupId：通常是项目的组id。-Dfile：要引入的jar包路径。-Dversion：版本。
面向对象编程基础——Java学习笔记
"Java学习笔记是一份非常适合Java初学者的资料，主要讲解了Java的面向对象编程概念，强调了面向对象编程的优点和实践方法。笔记中涵盖了类、对象、属性和方法等基础知识，并讨论了对象的高内聚、低耦合原则以及复用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值