主页 | 程序员H

TodoList 本地存储版

浏览器本地存储

localStorage、sessionStorage 可实现浏览器本地存储，它们统称为 Web Storage
存储内容的格式为：字符串类型的键值对，存储大小一般为：5MB~10MB

1. 一维数组

数组的说明

数组（array）：可以理解为多个相同数据类型的变量的组合。

目的：为了便于在内存中对数据进行统一管理。
一维数组的声明与初始化

（1）静态初始化：数组的赋值和数组元素的赋值同时进行。
```
int[] ids1 = new int[]{1,2,3,4,5,6,7};
int[] ids2 = {1,2,3,4,5,6,7};
```
（2）动态初始化：数组的赋值和数组元素的赋值分开进行。
```
String[] names = new String[3];
```
一维数组的引用

通过下角标的方式进行调用（下角标从0开始，到数组长度-1结束）。

总结：不管是静态初始化还是动态初始化，一旦数组初始化完成，其长度就确定了，而且长度是不可变的。
数组的属性

数组的长度，即为数组中元素的个数，可以通过 length 属性来获取。
一维数组的遍历

H2024/12/11大约 4 分钟

基本语法

1. 标识符的使用

规则

（1）由26个英文字母大小写，0-9，_或$组成；

（2）数字不可以开头；

（3）不可以使用关键字和保留字，但能包含关键字和保留字；

（4）Java中严格区分大小写，长度无限制；

（5）标识符不能包含空格。
规范

（1）包名：多单词组成时字母都是小写：xxxyyyzzz；

（2）类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz；

（3）变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz；

（4）常量名：所有字母大写，多单词组成时，单词之间用_连接：XXX_YYY_ZZZ。
注意

在起名字时，为了提高阅读性，要尽量“见名知意”。

H2024/12/11大约 4 分钟

集合

1. 数组与集合

内存中多个相同数据类型的存储“容器”：①数组 ②集合

对应的，数据的持久化：①数据库 ②文件（.txt,.jpg,...） ③xml文件
数组存储的特点

①一旦初始化，其长度就确定了；

②存储有序的、重复的数据；

③声明的类型，就决定了只能操作此类型的元素。

数组存储的弊端：

①一旦初始化，其长度就不可变；

②数组中涉及到数据的增删改查的方法比较少，不及集合；

③不能存放无序的、要求不可重复的数据。
集合存储的优点

（1）使用集合，可以不用考虑长度问题，直接添加即可；

（2）集合中提供了丰富的方法，便于数据的操作（CRUD）；

（3）操作的数据特点更丰富，可以存储无序的、不可重复的；有序的、可重复的；键值对特点。
数据结构研究的问题

（1）数据与数据之间的逻辑关系：一对一，一对多，多对多；

（2）数据的存储结构：①顺序存储（典型：一维数组）②链式存储。
```
// 单向链表
class A {
	A next;
}
// 双向链表
class A {
	A prev;
	A next;
}
// 二叉树
class A {
	A left;
	A right;
}
```

H2024/12/11大约 20 分钟

Java 常用类

1. String、StringBuffer、StringBuilder

（一）java.lang.String 类

特点

String 的不可变性

体现：

①给现有的字符串添加一个新的字符串，不能在原有的字符串后面添加，而必须声明一个新的内存空间，存放新的字符串；

②给现有的字符串重新赋值，不能在原有的常量池对应的字符串的位置赋值，必须重新声明一个新的内存空间，存放新的字符串；

③现有的字符串调用 replace() 方法，仍然声明一个新的内存空间，存放修改以后的字符串。
内存的存储结构

String 声明的变量，我们称为字符串，本质上数据存放在字符串常量池中，字符串常量池存放在方法区中。

jdk 6：方法区（具体的实现就是永久代--->堆：新生代、老年代、永久代）；

jdk 7：方法区取消，统一归入堆；

jdk 8：元空间取代原的方法区
String 的实例化方式

方式一：通过字面量定义的方式；

方式二：通过new + 构造器的方式。

二者区别：

①字面量的方式：地址值对应的数据声明在方法区中的字符串常量池；

②new + 构造器的方式：地址值对应的数据声明在堆空间中（堆空间中对应的 String 对象里存的是对应声明在字符串常量池中的字符串（若有，则不用创建；若无，就创建）的地址值）。
```
// 方式一：通过字面量的方式
String s1 = "hello";
String s2 = "hello";
		
// 方式二：通过new + 构造器的方式
String s3 = new String("hello");
String s4 = new String("hello");
		
System.out.println(s1 == s2);// true
System.out.println(s1 == s3);// false
System.out.println(s3 == s4);// false
```

H2024/12/11大约 12 分钟

枚举类和注解

1. 枚举类的使用

枚举类的理解

如果一个类中的对象的个数是有限可列的，那么我们说此类是一个枚举类。

--> 如何定义枚举类？

方法一：自定义枚举类；

方法二：jdk 5.0 新增了enum 的方式。
如何自定义枚举类？步骤

class Season {
	// 1.提供类的对象的属性
	private final String seasonName;
	private final String seasonDesc;
	
	// 2.提供构造器,私的
	private Season(String seasonName,String seasonDesc) {
		this.seasonName = seasonName;
		this.seasonDesc = seasonDesc;
	}
	
	// 3.提供当前枚举类的对象
	public static final Season SPRING = new Season("春天", "春暖花开");
	public static final Season SUMMER = new Season("夏天", "夏日炎炎");
	public static final Season AUTUMN = new Season("秋天", "秋高气爽");
	public static final Season WINTER = new Season("冬天", "寒冬凛冽");

	public String getSeasonName() {
		return seasonName;
	}
	public String getSeasonDesc() {
		return seasonDesc;
	}
	@Override
	public String toString() {
		return "Season [seasonName=" + seasonName + ", seasonDesc=" + seasonDesc + "]";
	}		
}

H2024/12/11大约 3 分钟

异常处理

1. 异常

异常的体系结构

java.lang.Throwable

 	|----- java.lang.Error：错误

 			|---- StackOverflowError

 			|---- OOM

 	|-----java.lang.Exception：异常

 			|----- 编译时异常(非RuntimeException)：执行javac.exe命令时，报出的异常

 			|----- 运行时异常(RuntimeException)：执行java.exe命令时，报出的异常

Error：错误

（1）java 虚拟机无法解决的严重问题；

比如：JVM系统内部错误、资源耗尽等严重情况。例：StackOverflowError 和 OOM。

（2）一般不编写针对性的代码进行处理。
Exception：异常

（1）其他因编程错误或偶然的外在因素导致的一般性问题；

（2）可以使用针对性的代码进行处理。
从程序执行过程，看编译时异常和运行时异常

H2024/12/11大约 7 分钟

泛型

1. 泛型在集合中的使用

在集合中使用泛型的例子

@Test
public void test1() {
	List list = new ArrayList();
	list.add(89);
	list.add(76);
	list.add(66);
	list.add(54);
	// 问题一：类型不安全
	list.add("AA");

	for(int i = 0;i < list.size();i++) {
		Object obj = list.get(i);
		// 问题二：需要强转，一方面繁琐，另一方面可能报ClassCastException
		int score = (Integer) obj;
		System.out.println(score);
	}
}

例子1：

@Test
public void test2() {
	List<Integer> list = new ArrayList<Integer>();
	list.add(67);
	list.add(54);
	list.add(87);
	// list.add("MM");

	Iterator<Integer> iterator = list.iterator();
	while(iterator.hasNext()){
		Integer score = iterator.next();
		System.out.println(score);
	}

    // 不允许。
    // List<int> list = new ArrayList<int>();
}

例子2：

@Test
public void test3() {
	HashMap<String,Integer> map = new HashMap<>(); // 类型推断：int[] arr = {1,2,3};

	map.put("Tom", 12);
	map.put("Lilei", 23);
	map.put("HanMeimei", 33);
	map.put("Jim", 14);
	// map.put(12, "Jerry");

	Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
	Iterator<Map.Entry<String,Integer>> iterator =entrySet.iterator();
	while(iterator.hasNext()){
		Entry<String, Integer> entry = iterator.next();
		System.out.println(entry.getKey() + "-->" + entry.getValue());
	}
}

总结

（1）泛型参数只能使用引用数据类型，不能使用基本数据类型；

（2）集合中，如果没有使用泛型，则默认使用 Object 类型；

如果集合中使用泛型，则集合的相关属性、方法中，凡是使用到类或接口泛型参数的地方，都要调整为具体的泛型类型。

（3）什么时候使用泛型呢？

首先，类或接口应该声明为泛型类、泛型接口；

其次，在实例化类时，就可以指明泛型参数的类型。

H2024/12/11大约 4 分钟

IO流

1. File 类的使用

java.io.File 类的使用

（1）FIle 类的一个对象，代表着一个文件（.txt , .doc , .jpg , .avi等）或文件目录；

（2）本章涉及到的 File，流相关的类，都定义在 java.io 包下；

（3）File 类的对象，如果作为一个文件，就可以理解作为一个端点（起始点、目标点）被流所使用；

代码上的体现：常常将 File 类的对象，作为参数传递给流的构造器中。

（4）File 类中提供了文件或文件目录的创建、重命名、长度、删除等操作，但是并没涉及到文件内容的读写。如果涉及到文件内容的读写的话，就需要使用流。
File 类的实例化

H2024/12/11大约 12 分钟

多线程

1. 程序、线程、进程的理解

程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合，即指一段静态的代码，静态对象。

进程（process）：是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。——生命周期。

①如：运行中的QQ、运行中的QQ播放器；

②进程是动态的，程序是静态的；

③进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域。

H2024/12/11大约 10 分钟