Java SE进阶知识笔记

偏执的太偏执、 2022-05-12 09:00 219阅读 0赞

**1.String类**  
一旦创建了String对象，那么它的值就无法改变了，如果要对字符串做很多修改，应该使用StringBuffer类和StringBuilder类。  
**常用方法:**  
int length():返回字串长度。  
char charAt(int index):返回指定索引处的 char 值。  
boolean equals(Object anObject):将此字符串与指定的对象比较。  
int indexOf(int ch):返回指定字符在此字符串中第一次出现处的索引。  
int indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引，从指定的索  
引开始。  
String replace(char oldChar,char newChar):返回一个新的字符串，它是通过用newChar替换此字符串中出  
现的所有oldChar得到的。  
String substring(int beginIndex):返回一个新的字符串，它是此字符串的一个子字符串。  
char\[\] toCharArray():将此字符串转换为一个新的字符数组。  
String trim():返回字符串的副本，忽略前导空白和尾部空白。  
int compareTo(String anotherString):按字典顺序比较两个字符串。  
**2.StringBuffer类和StringBuilder类**  
StringBuffer和StringBuilder类能够被多次的修改，并且不产生新的使用对象。  
StringBuffer和StringBuilder之间最大的不同在于StringBuilder的方法不是线程安全的(不能同步访问)。  
由于StringBuilder相较于StringBuffer有速度优势，所以大多数情况下还是建议使用StringBuilder类。然而应用程序要求线程安全的情况下，则必须使用StringBuffer类。  
**eg:**  
public class Test\{  
public static void main(String args\[\])\{  
StringBuffer sBuffer = new StringBuffer("测试：");  
sBuffer.append("第一次增长，");  
sBuffer.append("第二次增长，");  
sBuffer.append("第三次增长");  
System.out.println(sBuffer);  
\}  
\}  
**主要方法:**  
public StringBuffer append(String s):将指定的字符串追加到此字符序列。  
public StringBuffer reverse():将此字符序列用其反转形式取代。  
public delete(int start, int end):移除此序列的子字符串中的字符。  
public insert(int offset, int i):将 int 参数的字符串表示形式插入此序列中。  
replace(int start, int end, String str):使用给定 String 中的字符替换此序列的子字符串中的字符。  
其余的方法大部分和String类的相同  
**3.Arrays类**  
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。  
**具有以下功能：**  
给数组赋值：通过 fill 方法。  
对数组排序：通过 sort 方法,按升序。  
比较数组：通过 equals 方法比较数组中元素值是否相等。  
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。  
**4.IO**  
Java 的控制台输入由 System.in 完成。为了获得一个绑定到控制台的字符流，你可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流。  
**eg:**  
**读取单个字符:**  
import java.io.\*;  
public class BRRead \{  
public static void main(String args\[\]) throws IOException \{  
char c;  
// 使用 System.in 创建 BufferedReader  
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
System.out.println("输入字符, 按下 'q' 键退出。");  
// 读取字符  
do \{  
c = (char) br.read();  
System.out.println(c);  
\} while (c != 'q');  
\}  
\}  
**读取字符串:**  
import java.io.\*;  
public class BRReadLines \{  
public static void main(String args\[\]) throws IOException \{  
// 使用 System.in 创建 BufferedReader  
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
String str;  
System.out.println("Enter lines of text.");  
System.out.println("Enter 'end' to quit.");  
do \{  
str = br.readLine();  
System.out.println(str);  
\} while (!str.equals("end"));  
\}  
\}  
**5.文件流**  
**(1)FileInputStream**  
该流用于从文件读取数据，它的对象可以用关键字 new 来创建。  
有多种构造方法可用来创建对象。  
可以使用字符串类型的文件名来创建一个输入流对象来读取文件：  
InputStream f = new FileInputStream("C:/java/hello");  
也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：  
File f = new File("C:/java/hello");  
InputStream out = new FileInputStream(f);

**主要方法:**  
public void close() throws IOException\{\}：关闭此文件输入流并释放与此流有关的所有系统资源。  
抛出IOException异常。  
protected void finalize()throws IOException\{\}这个方法清除与该文件的连接。确保在不再引用文 件输入流时调用其 close 方法。抛出IOException异常。  
public int read(int r)throws IOException\{\}:这个方法从InputStream对象读取指定字节的数据。返回为整数值。返回下一字节数据，如果已经到结尾则返回-1。  
public int read(byte\[\] r) throws IOException\{\}:这个方法从输入流读取r.length长度的字节。  
返回读取的字节数。如果是文件结尾则返回-1。  
public int available() throws IOException\{\}返回下一次对此输入流调用的方法可以不受阻塞地从  
此输入流读取的字节数。返回一个整数值。  
**(2)FileOutputStream**  
该类用来创建一个文件并向文件中写数据。  
如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。  
有两个构造方法可以用来创建 FileOutputStream 对象。  
使用字符串类型的文件名来创建一个输出流对象：  
OutputStream f = new FileOutputStream("C:/java/hello")  
也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象：  
File f = new File("C:/java/hello");  
OutputStream f = new FileOutputStream(f);  
**常用方法:**  
public void close() throws IOException\{\}:关闭此文件输入流并释放与此流有关的所有系统资源。  
抛出IOException异常。  
protected void finalize()throws IOException\{\}：这个方法清除与该文件的连接。确保在不再引用  
文件输入流时调用其close 方法。抛出IOException异常。  
public void write(int w)throws IOException\{\}:这个方法把指定的字节写到输出流中。  
public void write(byte\[\] w):把指定数组中w.length长度的字节写到OutputStream中。  
**eg：**  
import java.io.\*;  
public class fileStreamTest \{  
public static void main(String args\[\]) \{  
try \{  
byte bWrite\[\] = \{ 11, 21, 3, 40, 5 \};  
OutputStream os = new FileOutputStream("test.txt");  
for (int x = 0; x < bWrite.length; x++) \{  
os.write(bWrite\[x\]); // writes the bytes  
\}  
os.close();  
InputStream is = new FileInputStream("test.txt");  
int size = is.available();  
for (int i = 0; i < size; i++) \{  
System.out.print((char) is.read() + " ");  
\}  
is.close();  
\} catch (IOException e) \{  
System.out.print("Exception");  
\}  
\}  
\}  
**解决乱码问题:**  
import java.io.\*;  
public class fileStreamTest2 \{  
public static void main(String\[\] args) throws IOException \{  
File f = new File("a.txt");  
FileOutputStream fop = new FileOutputStream(f);  
// 构建FileOutputStream对象,文件不存在会自动新建  
OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");  
// 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk  
writer.append("中文输入");  
// 写入到缓冲区  
writer.append("\\r\\n");  
// 换行  
writer.append("English");  
// 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入  
writer.close();  
// 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉  
fop.close();  
// 关闭输出流,释放系统资源  
FileInputStream fip = new FileInputStream(f);  
// 构建FileInputStream对象  
InputStreamReader reader = new InputStreamReader(fip, "UTF-8");  
// 构建InputStreamReader对象,编码与写入相同  
StringBuffer sb = new StringBuffer();  
while (reader.ready()) \{  
sb.append((char) reader.read());  
// 转成char加到StringBuffer对象中  
\}  
System.out.println(sb.toString());  
reader.close();  
// 关闭读取流  
fip.close();  
// 关闭输入流,释放系统资源  
\}  
\}  
**6.Scanner类**  
Java Scanner 类  
java.util.Scanner 是 Java5 的新特征，我们可以通过Scanner类来获取用户的输入。  
创建Scanner对象的基本语法：  
Scanner s = new Scanner(System.in);  
演示一个最简单的数据输入，并通过 Scanner 类的 next() 与 nextLine()方法获取输入的字符串，  
在读取前我们一般需要使用 hasNext 与 hasNextLine 判断是否还有输入的数据。

**eg:**  
import java.util.Scanner;  
public class ScannerDemo \{  
public static void main(String\[\] args) \{  
Scanner scan = new Scanner(System.in);  
// 从键盘接收数据

// next方式接收字符串  
System.out.println("next方式接收：");  
// 判断是否还有输入  
if (scan.hasNext()) \{  
String str1 = scan.next();  
System.out.println("输入的数据为：" + str1);  
\}  
scan.close();  
\}  
\}  
**使用nextLine方法:**  
import java.util.Scanner;  
public class ScannerDemo \{  
public static void main(String\[\] args) \{  
Scanner scan = new Scanner(System.in);  
// 从键盘接收数据  
  
// nextLine方式接收字符串  
System.out.println("nextLine方式接收：");  
// 判断是否还有输入  
if (scan.hasNextLine()) \{  
String str2 = scan.nextLine();  
System.out.println("输入的数据为：" + str2);  
\}  
scan.close();  
\}  
\}  
**next() 与 nextLine() 区别**  
next():  
1)一定要读取到有效字符后才可以结束输入。  
2)对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。  
3)只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。  
next() 不能得到带有空格的字符串。  
nextLine()：  
1)以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。  
2)可以获得空白。  
如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读。  
**eg:**  
import java.util.Scanner;  
public class ScannerDemo \{  
public static void main(String\[\] args) \{  
Scanner scan = new Scanner(System.in);  
// 从键盘接收数据  
int i = 0;  
float f = 0.0f;  
System.out.print("输入整数：");  
if (scan.hasNextInt()) \{  
// 判断输入的是否是整数  
i = scan.nextInt();  
// 接收整数  
System.out.println("整数数据：" + i);  
\} else \{  
// 输入错误的信息  
System.out.println("输入的不是整数！");  
\}  
System.out.print("输入小数：");  
if (scan.hasNextFloat()) \{  
// 判断输入的是否是小数  
f = scan.nextFloat();  
// 接收小数  
System.out.println("小数数据：" + f);  
\} else \{  
// 输入错误的信息  
System.out.println("输入的不是小数！");  
\}  
scan.close();  
\}  
\}  
**7.集合框架**  
**(1)集合接口**  
Collection 是最基本的集合接口，一个 Collection 代表一组 Object，即 Collection 的元素, Java不提供直接继承自Collection的类，只提供继承于的子接口(如List和set)。  
1)Collection 接口存储一组不唯一，无序的对象。  
2)List 接口  
List接口是一个有序的 Collection，使用此接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中位置，类似于数组的下标)来访问List中的元素，第一个元素的索引为 0，而且允许有相同的元素。  
List 接口存储一组不唯一，有序（插入顺序）的对象。  
3)Set  
Set 具有与 Collection 完全一样的接口，只是行为上不同，Set 不保存重复的元素。  
Set 接口存储一组唯一，无序的对象。  
4)SortedSet  
继承于Set保存有序的集合。  
5)Map  
Map 接口存储一组键值对象，提供key（键）到value（值）的映射。  
6)Map.Entry  
描述在一个Map中的一个元素（键/值对）。是一个Map的内部类。  
7)SortedMap  
继承于 Map，使 Key 保持在升序排列。  
8)Enumeration  
这是一个传统的接口和定义的方法，通过它可以枚举（一次获得一个）对象集合中的元素。这个传统接口已被迭代器取代  
**Set和List的区别**  
1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。  
2. Set检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。  
3. List和数组类似，可以动态增长，根据实际存储的数据的长度自动增长List的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。  
**(2)集合实现类**  
Java提供了一套实现了Collection接口的标准集合类。其中一些是具体类，这些类可以直接拿来使用，而另外一些是抽象类，提供了接口的部分实现。  
标准集合类：  
1)AbstractCollection:实现了大部分的集合接口。  
2)AbstractList:继承于AbstractCollection 并且实现了大部分List接口。  
3)AbstractSequentialList:继承于 AbstractList ，提供了对数据元素的链式访问而不是随机访问。  
4）LinkedList:该类实现了List接口，允许有null（空）元素。主要用于创建链表数据结构，该类没有同步方法，如果多个线程同时访问一个List，则必须自己实现访问同步，解决方法就是在创建List时候构造一个同步的List。例如：  
Listlist=Collections.synchronizedList(newLinkedList(...));  
LinkedList 查找效率低。  
5)ArrayList:该类也是实现了List的接口，实现了可变大小的数组，随机访问和遍历元素时，提供更好的性能。该类也是非同步的,在多线程的情况下不要使用。ArrayList 增长当前长度的50%，插入删除效率低。  
6)AbstractSet:继承于AbstractCollection 并且实现了大部分Set接口。  
7)HashSet:该类实现了Set接口，不允许出现重复元素，不保证集合中元素的顺序，允许包含值为null的元素，但最多只能一个。  
8)LinkedHashSet:具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。  
9)TreeSet:该类实现了Set接口，可以实现排序等功能。  
10)AbstractMap:实现了大部分的Map接口。  
11)HashMap:HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。该类实现了Map接口，根据键的HashCode值存储数据，具有很快的访问速度，最多允许一条记录的键为null，不支持线程同步。  
12)TreeMap:继承了AbstractMap，并且使用一颗树。  
13)WeakHashMap:继承AbstractMap类，使用弱密钥的哈希表。  
14)LinkedHashMap:继承于HashMap，使用元素的自然顺序对元素进行排序.  
15)IdentityHashMap:继承AbstractMap类，比较文档时使用引用相等。  
java.util包中定义的类  
1)Vector:该类和ArrayList非常相似，但是该类是同步的，可以用在多线程的情况，该类允许设置默认的增长长度，默认扩容方式为原来的2倍。  
2)Stack:栈是Vector的一个子类，它实现了一个标准的后进先出的栈。  
3)Dictionary:Dictionary 类是一个抽象类，用来存储键/值对，作用和Map类相似。  
4)Hashtable:Hashtable 是 Dictionary(字典) 类的子类，位于 java.util 包中。  
5)Properties:Properties 继承于Hashtable，表示一个持久的属性集，属性列表中每个键及其对应值都是  
一个字符串。  
6)BitSet:一个Bitset类创建一种特殊类型的数组来保存位值。BitSet中数组大小会随需要增加。  
**(3)集合遍历方法**  
通常情况下，你会希望遍历一个集合中的元素。例如，显示集合中的每个元素。  
一般遍历数组都是采用for循环或者增强for，这两个方法也可以用在集合框架，但是还有一种方法是采用迭代器遍历集合框架，它是一个对象，实现了Iterator 接口或ListIterator接口。  
迭代器，使你能够通过循环来得到或删除集合的元素。ListIterator 继承了Iterator，以允许双向遍历列表和修改元素。  
**eg:**  
import java.util.\*;  
public class Test\{  
public static void main(String\[\] args) \{  
List<String> list=new ArrayList<String>();  
list.add("Hello");  
list.add("World");  
list.add("HAHAHAHA");  
//第一种遍历方法使用foreach遍历List  
for (String str : list) \{ //也可以改写for(int i=0;i<list.size();i++)这种形式  
System.out.println(str);  
\}  
//第二种遍历，把链表变为数组相关的内容进行遍历  
String\[\] strArray=new String\[list.size()\];  
list.toArray(strArray);  
for(int i=0;i<strArray.length;i++) //这里也可以改写为 foreach(String str:strArray)这种形式  
\{  
System.out.println(strArray\[i\]);  
\}  
//第三种遍历 使用迭代器进行相关遍历  
Iterator<String> ite=list.iterator();  
while(ite.hasNext())//判断下一个元素之后有值  
\{  
System.out.println(ite.next());  
\}  
\}  
\}  
**遍历Map:**  
import java.util.\*;  
public class Test\{  
public static void main(String\[\] args) \{  
Map<String, String> map = new HashMap<String, String>();  
map.put("1", "value1");  
map.put("2", "value2");  
map.put("3", "value3");  
//第一种：普遍使用，二次取值  
System.out.println("通过Map.keySet遍历key和value：");  
for (String key : map.keySet()) \{  
System.out.println("key= "+ key + " and value= " + map.get(key));  
\}  
//第二种  
System.out.println("通过Map.entrySet使用iterator遍历key和value：");  
Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();  
while (it.hasNext()) \{  
Map.Entry<String, String> entry = it.next();  
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());  
\}  
//第三种：推荐，尤其是容量大时  
System.out.println("通过Map.entrySet遍历key和value");  
for (Map.Entry<String, String> entry : map.entrySet()) \{  
System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());  
\}  
//第四种  
System.out.println("通过Map.values()遍历所有的value，但不能遍历key");  
for (String v : map.values()) \{  
System.out.println("value= " + v);  
\}  
\}  
\}