02JavaSE基本语法总结

PV:

一、StringBuffer

1.类介绍

1
2
3
4
①线程安全的可变字符串序列，一个类似于String的字符串缓冲区，但是不能修改（就是不能通过加号+连接，String就可以）
②StringBuffer和String类的区别
	String是一个可改变的字符序列
	StringBuffer是一个可变的字符序列

2.构造方法

1
2
3
4
5
StringBuffer()	构造一个没有字符的字符串缓冲区，初始容量为16个字符
StringBuffer(int capacity)	构造一个没有字符的字符串缓冲区和指定初始容量
StringBuffer(CharSequence seq)	构造一个字符串缓冲区,其中包含与指定的 CharSequence相同的字符。
StringBuffer(String str)	构造一个初始化为指定字符串内容的字符串缓冲区。 
	Notes：从jdk5开始,为该类补充了一个单个线程使用的等价类,即StringBuilder类,通常优先使用StringBuilder类,因为他支持所有相同操作,但是由于它不执行同步,所有速度更快

3.增删,替换翻转,截取()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
StringBuffer sb = new StringBuffer("abcd");
①添加
sb.append("str12");			//在末尾添加一个字符串
sb.insert(3,"hhh");			//在指定位置添加指定字符串
②删除
sb.deleteCharAt(3);			//删除指定1位置的字符 并返回本身
sb.delete(1,3);     //左闭右开
③清空缓冲区
sb.delete(0,sb.length());

④替换
sb.replace(0,3,"bai")	// 包含头不包含尾
⑤翻转
sb.reverse();
⑥截取
sb.substring(int start)		//从指定位置截取到末尾
sb.substring(int start,int end)		//从指定位置开始到结束位置，包括开始位置，不包括结束位置
// 截取 返回值不再是StringBuffer而是String

4.StringBuffer –> String

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
String --》 StringBuffer
	a.通过构造方法
		StringBuffer stringBuffer = new StringBuffer("woai");
		System.out.println(stringBuffer);       // 通过构造方法完成转换成String
	b.通过append()方法
		StringBuffer stringBuffer = new StringBuffer();
		stringBuffer.append("woai");
		System.out.println(stringBuffer);       // 通过append()方法完成转换成String

StringBuffer --》 String
	StringBuffer sb = new StringBuffer("woai1");
	a.通过构造方法
		String s = new String(sb);      // 通过构造方法
		System.out.println(s);
	b.通过toString()方法
		String string = sb.toString();      //通过toString()方法
		System.out.println("string = " + string);
	c.通过subString(0,length);
	    String substring = sb.substring(0, sb.length());
		System.out.println(substring);

5.数组 –> 字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
举例：
		int [] arr = {1,2,3,};
	输出结果:
		"[1,2,3]"
	用StringBuff的功能实现：
		int[] arr = {1, 2, 3};
		StringBuffer stringBuffer = new StringBuffer();
		stringBuffer.append("[");
		for (int i = 0; i < arr.length; i++) {
			if (i == arr.length - 1) {
            stringBuffer.append(arr[i]).append("]");		//	使用这样的添加方式会减少垃圾的存在
			}else {
            stringBuffer.append(arr[i]).append(",");
			}
		}
		System.out.println(stringBuffer);

6.字符串翻转

1
通过StringBuffer进行翻转

7.StringBuffer和StringBuilder区别

1
2
3
4
5
6
StringBuffer是jdk1.0版本的，是线程安全的，效率低的 		(对于用户访问量大的bat 保证其稳定性，对于金融要求，保证其稳定，其他都不存在)
	StringBuilder是jdk1.5版本的，是线程不安全的，效率高的
	
	String和StringBuffer，StringBuilder的区别
		String是一个不可变的字符序列
		StringBuffer，StringBuilder是可变的字符序列

8.String和StringBuffer作为参数传递

1
2
3
4
5
6
7
8
9
10
11
12
基本数据类型的值传递，不改变其值
引用数据类型的值传递，改变其值		//	因为传递的是内存地址，

String s = "heihei";
   System.out.println(s);
   change(s);
   System.out.println(s);	//	heihei
   System.out.println("------------------");
   StringBuffer sb = new StringBuffer();
   sb.append("hhhhhh");
   change(sb);
   System.out.println("sb = " + sb);	// heiheihhhhhh

9.数组-冒泡,选择,二分排序

1
2
3
4
5
(1)冒泡
	// 数据元素：{24,69,80,57,13}
		相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处
(2)选择
(3)二分排序

10.Arrays类

1
2


11.Interger类

1
2


12.String –> int

1
2


13.Interger面试题

1
2


二、正则表达式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1.概述和简单使用
	 * [abc] a,b或c(简单类)
	 * [^abc] 任何字符,除了a,b,或c (否定)
	 * [a-zA-Z]   a到 z 或 A 到 Z, 两头的字母包括在内（范围）
	 * [a-d[m-p]] a到 d 或 m到p  ;    [a-dm-p]   (并集)
	 * [a-z&&[def]] d,e,或 f (交集)
	 * [a-z&&[^bc]] a 到 z ，除了b和c;  [ad-z](减去)
	 * [a-z&&[^m-p]] a 到 z 而非 m 到 p;  [a-lq-z](减去)
	 
2.预定义字符类
	\d 数字:[0-9]
	\D 非数字:[^0-9]
	\s 空白字符:[\t\n\x0B\f\r]
	\S 非空白字符:[^\s]
	\w 单词字符:[a-zA-Z_0-9]
	\W 非单词字符：[^\w]
	
3.常见对象(数量词)
	X? X,一次或一次也没有
	X* X,零次或多次
	X+ X,一次或多次
	X{n} X,恰好n次
	X{n,} X,至少n次
	X{n,m} X,至少n次,但是不超过m次

​

二、Collection

三、List

四、Set

五、Map

1
********** 总结 *************
1
Collection
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
* List	(存取有序，有索引，可以重复)
	-ArrayList
		底层是数组实现的，线程不安全，查找和修改快，增和删比较慢
	-LinkedList
		底层是链表实现的，线程不安全，增删快，查找和修改比较慢
	-Vector
		底层是数组实现的，线程安全，无论增删 查找都慢
		
	notes：
		如果查找和修改多，用ArrayList
		如果增和删多，用LinkedList
		如果都多，用ArrayList
* Set (存取无序，无需索引，不可以重复)
	-HashSet
		底层是哈希算法实现的
		LinkedHashSet	
			底层是链表实现，但是也可以保证元素的唯一性，和HasSet原理一样
	-TreeSet
		底层是二叉树算法实现的
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
	notes：
		一般在开发的时候不需要对存储的元素排序，所以在开发的时候大多用HashSet , HashSet的效率比较高
		TreeSet在面试的时候比较多，问你有几种排序方式，和几种排序方式的区别。

* Map

	HashMap	
		底层是哈希算法，针对键
		LinkedHashMap
			底层是链表，针对键
			
	TreeMap
		底层是二叉树算法，针对键
		
	notes：
		开发中用HashMap比较多

六、异常&IO(文件类)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
1.异常概述和分类
	*概述
		是java程序在运行过程中出现的错误
	*分类
		通过API可以查看Throwable 有两个子类error 和exception
		error
			服务器宕机，数据库崩溃
		Exception
			*RuntimeException  运行时异常

2.异常(关于finally关键字的面试题)
	A.final , finally 和 finalize的区别
	B.如果catch里面有return 语句请问finally的代码还会执行吗? 如果会是在return前还是后

3.自定义异常
	继承Exception	编译时异常
	继承RuntimeException	运行时异常
	
4.异常的注意事项及使用异常处理
	A:注意事项
		a.子类重写父类的方法时,子类的方法必须抛出相同的异常或父类异常的子类.
		b.如果父类抛出多个异常,子类重写父类时,只能抛出相同的异常或者时他的子集,子集不能抛出父类没有的异常
		c.如果被重写的方法没有异常抛出，那么子类的方法绝不可以抛出异常，如果子类方法内有异常发生，那么子类只能try，不能throws

	B:如何使用异常处理
		原则：如果该功能的内部可以将问题处理，就用try ，如果处理不了，交由调用者处理，这里用throws
		区别：
			*后续程序需要继续运行就try
			*后续程序不需要运行就throws
			
		*如果JDK没有提供对应的异常，需要自定义异常

Powered by Hexo and Hexo-theme-hiker

Copyright © 2016 - 2018 Francis的个人博客 All Rights Reserved.

UV : | PV :