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);
}
}
}