主要内容
详细内容
String类
API介绍
API全称是Application Programming Interface，API是应用程序编程接口，指的是一些预先定义好的类。
Java API是Oracle公司提供给我们使用的类，这些类已经将底层实现封装了起来，我们无需关心这些类的实现方法，只需要知道如何使用这些类即可。
常用API
构造函数
public final class String
extends Object
implements Serializable, Comparable<String>, CharSequenceString类代表字符串，Java程序中的所有字符串字面值都作为此类的实例实现。字符串是常量；它们的值在创建之后不能修改；字符串缓冲区支持可变的字符串。因为String对象是不可变的，所以可以共享。以下代码：
String str = “abc”;
等价于：
char [] data = {'a','b','c'};
String str = new String(data);String类的构造函数一共有以下9种：
（1）String():无参构造函数；
String str = new String();
str = "hello blackhorse";
sop(str);（2）String(byte [] bytes):传入一个字节数组作为参数
byte[] bytes = {1,2,3,4,5,6,7,8};
String str = new String(bytes);
sop(str);（3）String(byte[] bytes, int offset, int length) :把字节数组的一部分转换成一个字符串
byte[] bytes = {1,2,3,4,5,6,7,8};
String str = new String(bytes,1,2);
sop(str);（4）String(char[] value) :传入一个字符数组作为参数；
char[] chs = {'a','b','c','d','e'};
String str = new String(chs);
sop(str);（5）String(char[] value, int offset, int count)：把字符数组的一部分转换成一个字符串
char[] chs = {'a','b','c','d','e'};
String str = new String(chs，1，2);
sop(str);（6）String(String original) ：新建的字符串是该参数字符串的副本；
char []chs ={'a','b','c','d','e'};
String s = new String(chs,1,3);
String ss = new String(s);
sop(ss);（7）String(StringBuffer buffer)：分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列；
（8）String(StringBuilder builder) ：分配一个新的字符串，它包含字符串生成器参数中当前包含的字符序列；
（9）直接把字符串常量赋值给字符串引用对象。
String str = "hello world";
sop(str);常用方法
（1）获取：
int length():获取长度，字符串中包含的字符数，也就是字符串的长度。
char charAt(int index)：返回指定索引处的 char 值，根据位置获取位置上的某个字符；
根据字符获取该字符在字符串中位置。
int indexOf(int ch)：返回指定字符在此字符串中第一次出现处的索引
int indexOf(int ch,int fromIndex)：返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str,int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。（2）判断
字符串中是否包含某一个子串
boolean contains(str):判断字符串是否包含
特殊之处：indexOf(str):用于对指定字符串的判断是否包含。
if(str.indexOf("aa") != -1)而且该方法既可以判断又可以获取出现的位置
字符串是否有内容
boolean isEmpty():原理就是判断长度是否为0;
字符串是否以指定内容开头:boolean startsWith(str);
字符串是否以指定内容结束:boolean endsWith(str);
判断字符串内容是否相同，复写了Object类中equals方法
boolean equals(Object anObject)：将此字符串与指定的对象比较
判断内容是否相同，并忽略大小写
boolean equalsIgnoreCase(String anotherString)：将此 String 与另一个 String 比较，不考虑大小写（3）转换
将字符数组转成字符串
构造函数：String (char [])
String (char [],offset,count):将字符数组的一部分转成字符串
静态方法：static String copyValueOf(char[] data,int offset,int count)
static String valueOf(char [])
将字符串转成字符数组
char[] toCharArray()：将此字符串转换为一个新的字符数组
将字节数组转成字符串
String (byte [],offset,count):将字节数组的一部分转成字符串
将字符串转成字节数组
byte[] getBytes() ：使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
将基本数据类型转成字符串
static String valueOf(int )
static String valueOf(double )
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。（4）替换
String replace(char oldChar,char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
String replace(CharSequence target,CharSequence replacement) ：使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串（5）切割
String [] spilt(regex):根据给定正则表达式的匹配拆分此字符串。（6）获取子串的一部分
String substring(int beginIndex)：返回一个新的字符串，它是此字符串的一个子字符串。
该子字符串从指定索引处的字符开始，直到此字符串末尾。
String substring(int beginIndex,int endIndex):返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符（7）转换，去空格，比较
将字符串转成大写或者小写
String toLowerCase() ：将此 String 中的所有字符都转换为小写
toUpperCase()：将此 String 中的所有字符都转换为大写。
将字符串两端的多个空格去除
String trim()：返回字符串的副本，忽略前导空白和尾部空白
对两个字符串进行自然顺序的比较
int compareTo(String anotherString)：按字典顺序比较两个字符串StringBuffer及StringBuilder
（1）存储
StringBuffer append():将指定数据作为参数添加到已有数据的结尾处
StringBuffer insert(index,数据类型)：可以将数据插入在指定位置上。（2）删除
StringBuffer delete(int start, int end)：移除此序列的子字符串中的字符，其中：start - 起始索引（包含），end - 结束索引（不包含）
StringBuffer deleteCharAt(int index)：移除此序列指定位置的 char（3）获取
char charAt(int index)：返回此序列中指定索引处的 char 值;
indexOf(String str):返回第一次出现的指定子字符串在该字符串中的索引（4）修改
StringBuffer replace(int start, int end, String str):使用给定 String 中的字符替换此序列的子字符串中的字符
void setCharAt(int index, char ch): 将给定索引处的字符设置为 ch（5）反转
StringBuffer reverse()：将此字符序列用其反转形式取代。（6） 将字符从此序列复制到目标字符数组 dst 即，将缓冲区总的指定数据存储到指定数组中。
void getChars(int srcBegin,int srcEnd,char[] dst,int dstBegin) （7）StringBuffer和StringBuilder 的比较
1) JDK 1.5版本之后才出现StringBuilder
2) StringBuffer是线程同步，用于单线程程序时，需要判断锁，效率低
3) StringBuilder是线程不同步的，线程不安全。用于单线程程序，效率高；开发建议使用StringBuilder
4) 将 StringBuilder 的实例用于多个线程是不安全的。如果需要这样的同步，则建议使用 StringBuffer。
5) 升级三个因素：提高效率；简化书写以及提高安全性。
练习题：
（1）模拟一个trim方法，去除字符串两端的空格。
/**
* 思路：1，判断字符串的第一个位置是否是空格，如果是则继续判断，如果不是知道不是空格为止，结尾处判断空格也是如此；
* 2，当开始和结尾都判断到都不是空格的时候，就是要获取的字符串。
* */
public class Exercise01
{
public static void main(String[] args)
{
String str = " ab cdefg ";
// 打印首尾两端未去除空格的字符串
sop("(" + str + ")");
// 调用myTrim()方法，并赋值给str
str = myTrim(str);
// 打印首尾两端去除空格的字符串
sop("(" + str + ")");
}
/**
* 模拟trim方法将首尾两端空格 去除
* @param str需要去除首尾空格的字符串
* */
public static String myTrim(String str)
{
int start = 0, end = str.length() - 1;
while (start <= end && str.charAt(start) == ' ')
{
start++;
}
while (start <= end && str.charAt(end) == ' ')
{
end--;
}
return str.substring(start, end + 1);
}
/**
* 将传入的字符串打印出来
*
* @param str需要打印的字符串
* */
public static void sop(String str)
{
System.out.println(str);
}
}（2）将一个字符串进行反转。将字符串中指定部分进行反转
/**
* 思路： 1，将字符串变成数组，对数组反转； 2，将反转后的数组变成字符串； 3，将需要反转部分的开始和结束位置作为参数传递即可。
* */
public class Exercise02
{
public static void main(String[] args)
{
String str = "abcdefghijkl";
// 打印未反转前的字符串数组
sop("(" + str + ")");
// 打印反转后的字符串数组
sop("(" + reverseString(str) + ")");
// 打印反转部分的字符串数组
sop("(" + reverseString(str, 6, 8) + ")");
}
/**
* 实现字符串部分反转
*
* @param str
* 需要反转的字符串
* @param start
* 字符串需要反转部分的开始位置
* @param end
* 字符串需要反转部分的结束位置
* */
private static String reverseString(String str, int start, int end)
{
// 将字符串变成数组
char[] chs = str.toCharArray();
// 反转数组
reverse(chs, start, end);
// 将数组编程字符串
return new String(chs);
}
/**
* 实现字符串反转
*
* @param str
* 需要反转的字符串
* */
private static String reverseString(String str)
{
return reverseString(str, 0, str.length() - 1);
}
/**
* 实现数组反转
*
* @param arr
* 需要反转的数组
* @param start
* 数组需要反转部分的开始位置
* @param end
* 数组需要反转部分的结束位置
* */
private static void reverse(char[] arr, int start, int end)
{
for (int startIndex = start, endIndex = end; startIndex < endIndex; startIndex++, endIndex--)
{
swap(arr, startIndex, endIndex);
}
}
/**
* 实现数组元素的交换
*
* @param arr
* 需要交换的数组
* @param start
* 数组需要交换部分的开始位置
* @param end
* 数组需要交换部分的结束位置
* */
private static void swap(char[] arr, int start, int end)
{
char temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
/**
* 将传入的字符串打印出来
*
* @param str需要打印的字符串
* */
public static void sop(String str)
{
System.out.println(str);
}
}（3）获取一个字符串在另一个字符串中出现的次数。比如字符串为"abkkcdkkefkkskk"
/**
* 思路： 1，定义一个变量表示计数器； 2，获取字符串"kk"第一次出现的位置；
* 3，在第一次出现为之后剩余的字符串中继续获取"kk"出现的位置，每获取到一次便计数一次； 4，当获取不到的时候表示计数完成。
* */
public class Exercise03
{
public static void main(String[] args)
{
String str = "abkkcdkkefkkskk";
sop("count = " + getSubCount(str, "kk"));
System.out.println("*******************");
sop("count = " + getSubCount_2(str, "kk"));
}
/**
*不需要截取子串
* @param str
* 传入的长串
*@param key
* 传入的子串
*@return count 返回子串在长串中出现的次数
* */
private static int getSubCount_2(String str, String key)
{
// 定义计数器，默认初始值为0
int count = 0;
int index = 0;
while ((index = str.indexOf(key, index)) != -1)
{
//将子串出现的位置打印出来
sop("index = " + index);
index = index + key.length();
count++;
}
return count;
}
/**
*需要截取子串
* @param str
* 传入的长串
*@param key
* 传入的子串
*@return count 返回子串在长串中出现的次数
* */
private static int getSubCount(String str, String key)
{
// 定义计数器，默认初始值为0
int count = 0;
int index = 0;
while ((index = str.indexOf(key)) != -1)
{
//将截取的子串打印出来
sop("str = " + str);
str = str.substring(index + key.length());
count++;
}
return count;
}
/**
* 将传入的字符串打印出来
* @param str需要打印的字符串
* */
public static void sop(String str)
{
System.out.println(str);
}
}（4）获取两个字符串中最大相同子串。
/**
*思路： 1，将短子串按照长度递减的方式获取到； 2，将每个获取到的子串去长串中判断是否会包含，如果包含则说明已经找到。
*/
public class Exercise04
{
public static void main(String[] args)
{
String longStr = "abcwerthelloyuiodef";
String shortStr = "cvhellobnm";
sop("最大子串为： " + getMaxSubString(longStr, shortStr));
}
/**
* 获取两个字符串中最大相同子串
* @param longStr
* 传入的长串
* @param shortStr
* 传入的短串
* @return 两个字符串中最大相同的子串
* */
private static String getMaxSubString(String longStr, String shortStr)
{
// 定义最长串和最短串字符串，并赋初始值为""
String max = "", min = "";
// 对最长串赋值
max = (longStr.length() > shortStr.length()) ? longStr : shortStr;
// 对最短串赋值
min = (max == longStr) ? shortStr : longStr;
// 打印出最长串和最短串
sop("max = " + max + "......" + "min = " + min);
for (int x = 0; x < min.length(); x++)
{
for (int y = 0, z = min.length() - x; z != min.length() + 1; y++, z++)
{
String temp = min.substring(y, z);
// 如果最长串里面包含临时获得的子串，则返回子串
if (max.contains(temp))
{
return temp;
}
}
}
return "";
}
/**
* 将传入的字符串打印出来
* @param str需要打印的字符串
* */
public static void sop(String str)
{
System.out.println(str);
}
}（5）对字符串排序。
/**
*思路： 1，将字符串变成数组； 2，对数组进行排序； 3，将数组变成字符串。 4，使用Arrays.sort()方法便可对字符串进行排序
*/
public class Exercise05
{
public static void main(String[] args)
{
String str = "zxcvbasdfg";
char[] chs = str.toCharArray();
sop("排序前字符串为：" + str);
Arrays.sort(chs);
sop("使用Arrays.sort()方法排序后字符串： " + new String(chs));
str = sortString(str);
sop("自定义方法实现排序后字符串为：" + str);
}
/**
*对字符串进行排序
*@param str 需要排序的字符串
* */
private static String sortString(String str)
{
//调用string2Array()方法将字符串变为数组
char[] chs = string2Array(str);
//调用sortArray()方法将数组排序
sortArray(chs);
//调用array2String()方法将数组变成字符串，并且返回
return array2String(chs);
}
/**
* 将数组变成字符串
* @param chs 需要转换的数组
* */
private static String array2String(char[] chs)
{
return new String(chs);
}
/**
* 对数组进行排序
* @param chs 需要排序的数组
* */
private static void sortArray(char[] chs)
{
for (int i = 0; i < chs.length - 1; i++)
{
for (int j = i + 1; j < chs.length; j++)
{
if (chs[i] > chs[j])
{
swap(chs, i, j);
}
}
}
}
/**
* 将数组中的值进行交换
* @param chs 需要交换的数组
* */
private static void swap(char[] chs, int i, int j)
{
char temp = chs[i];
chs[i] = chs[j];
chs[j] = temp;
}
/**
* 将字符串变成数组
* @param chs 需要转换的字符串
* */
private static char[] string2Array(String str)
{
return str.toCharArray();
}
/**
* 将传入的字符串打印出来
* @param str需要打印的字符串
* */
public static void sop(String str)
{
System.out.println(str);
}
}（6）要求对字符串中的数值进行排序。生成一个数值从小到大新字符串。
/**
* 解题思路：
* 1，将字符串切割，变成字符串数组；
* 2，将字符串数组转换层int型数组；
* 3，对int型数组进行排序；
* 4，将int型数组变成字符串。
*/
public class Exercise06
{
public static void main(String[] args)
{
String str = "12 0 99 -7 30 4 100 13";
str = numberStringSort(str);
System.out.println(str);
}
/**
* 对字符串中的数值进行排序，生成一个数值从小到大的新字符串
* @param str 需要排序的字符串
* */
private static String numberStringSort(String str)
{
String []arr = spiltString(str);
int [] nums = toIntArray(arr);
Arrays.sort(nums);
return intArray2String(nums);
}
/**
* 将整型数组变成字符串数组
* @param nums 传入的整型数组
* */
private static String intArray2String(int[] nums)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < nums.length; i++)
{
if (i!=nums.length-1)
{
sb.append(nums[i] + " ");
}
else
{
sb.append(nums[i]);
}
}
return sb.toString();
}
/**
* 将字符串数组变成整型数组
* @param arr 传入的字符串数组
* */
private static int[] toIntArray(String[] arr)
{
int [] nums = new int[arr.length];
for (int i = 0; i < arr.length; i++)
{
nums[i] = Integer.parseInt(arr[i]);
}
return nums;
}
/**
* 将传入的字符串分割成数组
* @param str 传入的字符串
* */
private static String[] spiltString(String str)
{
return str.split(" ");
}
}集合类
集合概念
使用工具画的关系图如下所示：
（1）为什么出现集合类？
面向对象对事物的体现都是以对象的形式存在的，为了方便对多个对象的操作，就对对象进行存储，集合是存储对象最常用的一种方式。
（2）数组和集合都是容器，两者的区别？
1）数组长度是固定的，而集合的长度是可变的；
2）数组值可以存储对象，存储基本数据类型，而集合只能存储对象；
3）数组存储数据类型是固定的，而集合存储的数据类型不固定。
（3）集合类的特点：
1）集合只能存储对象；
2）集合的长度是可变的；
3）集合可以存储不同类型的变量。
集合接口
（1）Collection接口
public interface Collection<E> extends Iterable<E>Collection接口是List、Set和Queue接口的父接口，该接口里定义的方法可以用于这三种集合当中，该集合中有以下方法：
1）添加
add(e)：向集合中添加指定的元素；
addAll(collection)：向集合中添加所有的元素；2）删除
remove(e)：移除此集合中指定的元素；
removeAll(collection)：移除此集合中所有的元素；
clear()：移除此集合中所有的元素；3 ）判断
contains(e)：判断此集合中是否含有此元素；
isEmpty()：判断此集合是否为空；4）获取
iterator()：返回在此集合的元素上进行迭代的迭代器；
size()：返回此集合中的元素数；5 ）获取交集
retainAll()：获取交集；6 ）集合变数组
toArray()：返回此集合中所有元素的数组。示例代码：
public class CollectionTest
{
public static void main(String[] args)
{
Collection c = new ArrayList();
// 添加元素
c.add("black horse");
c.add("itcast");
System.out.println("集合中的个数为： " + c.size());
// 删除指定元素
c.remove("itcast");
System.out.println("集合中的个数为： " + c.size());
// 判断是否包含指定的元素
boolean flag = c.contains("black horse");
System.out.println("flag = " + flag);
// 添加元素
c.add("Java 就业教程");
Collection books = new HashSet();
books.add("Java 就业教程");
books.add("Hibernate");
books.add("Struts");
books.add("Spring");
System.out.println("集合c中是否包含books的集合： " + c.containsAll(books));
//用c集合减去books集合中的元素
c.removeAll(books);
System.out.println("c集合的元素：" + c);
//删除c集合中的所有元素
c.clear();
System.out.println("c集合的元素：" + c);
}
}（2）Map接口
public interface Map<K,V>Map用于保存具有映射关系的数据，因此Map集合中保存着两组值，一组值用于保存Map的key，另一组用来保存Map里的value，key 和value都可以是任何引用类型的数据。
Key和value之间存在着单向的一对一关系，即通过指定的key，总能找到唯一的value值，如下图所示：
1）添加
put(K key, V value) ：将指定的值与此映射中的指定键关联；
putAll(Map<? extends K,? extends V> m) ：从指定映射中将所有的映射关系复制到此映射中；2 ）删除
clear() :从此映射中移除所有映射的关系；
remove(Object key) ：如果存在一个键的映射关系，则将其从此映射中移除；3）判断
containsValue(Object value) ：如果此映射将一个或多个键映射到指定值，则返回true；
containsKey(Object key) ：如果此映射包含指定键的映射关系，则返回true;
isEmpty() ：如果此映射中未包含键-值映射关系，则返回true;4 ）获取
get(Object key) ：返回指定键所映射的值，如果此映射中不包含该键的映射关系，则返回null;
size()： 返回此映射中的键值映射关系总数；
values() ：返回此映射中所包含的值的Collection视图；
entrySet() ：返回此映射中包含的映射关系的Set视图；
keySet() ：返回此映射中包含的键的Set视图。（3）Iterator 接口
public interface Iterator<E>Iterator接口用于遍历（或称为迭代访问）Collection集合中的元素，Iterator的对象被称为迭代器；该接口一共定义了以下三种方法;
hasNext():如果被迭代的集合元素还没有被遍历，则返回true；
next():返回集合里的下一个元素；
remove():删除集合里上一次next方法返回的元素；
示例代码如下所示：
public class IteratorTest
{
public static void main(String[] args)
{
//创建一个集合
Collection books = new HashSet();
//向集合中添加元素
books.add("Java");
books.add("Java Web");
books.add("Struts");
books.add("Hibernate");
books.add("Spring");
//获取books集合的迭代器
Iterator it = books.iterator();
//hasNext():表示判断该集合里的元素是否开始遍历
while(it.hasNext())
{
//next()方法返回的数据类型是Object类型，需要强制类型转换
String book = (String) it.next();
System.out.println(book);
if (book.equals("Java Web"))
{
//从集合中删除上一次next方法返回的元素
it.remove();
}
}
System.out.println(books);
}
}（4）Enumeration接口
public interface Enumeration<E>Enumeration接口是Iterator迭代器的“古老版本”，该接口包含以下两个方法：
hasMoreElements()：如果此迭代器里还有剩余元素，则返回true;
nextElement():返回该迭代器的下一个元素，如果还有的话，否则将抛出异常。该接口实现的方法较 Iterator 接口缺少了 remove 方法，建议使用 Iterator 迭代器，示例代码如下所示：
public class EnumerationTest
{
public static void main(String[] args)
{
Vector v = new Vector();
v.add("Java");
v.add("Java Web");
Hashtable scores = new Hashtable();
scores.put("Java", 99);
scores.put("Java Web", 95);
Enumeration em = v.elements();
while (em.hasMoreElements())
{
System.out.println(em.nextElement());
}
Enumeration keyEm = scores.keys();
while (keyEm.hasMoreElements())
{
Object key = keyEm.nextElement();
System.out.println(key + "---->" + scores.get(key));
}
}
}List
（1）特点
public interface List<E> extends Collection<E>List接口是Collection接口的一个子接口，List接口中的元素有如下特点：
1)元素是有序的（存取顺序和取出顺序是一致的）；
2)元素是可以重复的；
3)对角标的操作都是该体系的特有方法，因为是有序的。
该接口特有的方法如下所示：
1）增加
add(index,element):在指定位置加入元素；
addAll(index,Collection):将指定Collection中的所有元素插入到列表的指定位置。
2）删除
remove(index):移除指定位置的元素;
3）修改
set(index,element):修改指定位置的元素；
4）查询
get(index):获取指定位置的元素；
subList(from,to):从一个大的List中截取一个小的List
listIterator():返回一个List接口特有的迭代器；
int indexOf(obj):返回此列表中第一次出现的指定元素的索引，如果不存在则返回-1（2）ArrayList
public class ArrayList<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable底层的数据结构是数组数据结构，特点是查询速度快（因为带）角标，但是增删速度相对慢，因为当元素多时，增删一个元素则所有元素的角标都得改变；默认长度是10，当超过长度时候，按50%延长集合的长度。线程是不同步的。
1）构造方法摘要：
ArrayList()：构造一个初始容量为 10 的空列表。
ArrayList(Collection<? extends E> c)： 构造一个包含指定 collection 的元素的列表， ArrayList(int initialCapacity)： 构造一个具有指定初始容量的空列表。
2 ）方法摘要：
添加：
boolean add(E e)： 将指定的元素添加到此列表的尾部。
void add(int index, E element)： 将指定的元素插入此列表中的指定位置。
boolean addAll(Collection<? extends E> c):按照指定 collection 的迭代器所返回的元素顺序， 将该 collection 中的所有元素添加到此列表的尾部
boolean addAll(int index, Collection<? extends E> c)： 从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
删除：
void clear(): 移除此列表中的所有元素。
E remove(int index): 移除此列表中指定位置上的元素。
boolean remove(Object o): 移除此列表中首次出现的指定元素（如果存在）。
protected void removeRange(int fromIndex, int toIndex): 移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
boolean removeAll(Collection<?> c): 从列表中移除指定 collection 中包含的其所有元素
获取：
E get(int index): 返回此列表中指定位置上的元素。
int indexOf(Object o): 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
int lastIndexOf(Object o) 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
public List<E> subList(int fromIndex,int toIndex): 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
Iterator<E> iterator(): 返回按适当顺序在列表的元素上进行迭代的迭代器。
ListIterator<E> listIterator(int index):返回列表中元素的列表迭代器(按适当顺序),从列表的指定位置开始。
修改：
E set(int index, E element): 用指定的元素替代此列表中指定位置上的元素。
示例代码（1）如下所示：
public class ListDemo
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
// 1，添加新的元素
al.add("Java01");
al.add("Java02");
al.add("Java03");
al.add("Java04");
// 2，在指定位置上添加元素
sop("原集合是：" + al);
al.add(1, "Java00");
sop("添加元素后集合为：" + al);
// 3，删除指定位置上的元素
al.remove(2);
sop("删除指定位置上的元素后集合为：" + al);
// 4，修改元素
al.set(2, "Java 002");
sop("修改元素后集合为：" + al);
// 5，通过角标获取元素
sop("通过角标获取的元素为：" + al.get(3));
// 6，获取所有的元素
System.out.println("通过普通方式获取所有元素：");
for (int x = 0; x < al.size(); x++)
{
System.out.println("al(" + x + ")" + al.get(x) + "\t");
}
// 7，通过迭代器获取所有的元素
for (Iterator it = al.iterator(); it.hasNext();)
{
sop("通过迭代器获取所有的元素：" + it.next());
}
// 8，通过indexOf获取对象的位置
sop("index = " + al.indexOf("Java03"));
// 9，通过subList获取元素
sop("通过subList获取元素:" + al.subList(2, 3));
}
/**
* 将传入的字符串打印出来
* @param str需要打印的字符串
* */
public static void sop(String str)
{
System.out.println(str);
}
}示例代码（2）如下所示：
public class ArrayListDemo
{
public static void main(String[] args)
{
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("lisi01", 30));
al.add(new Person("lisi02", 31));
al.add(new Person("lisi02", 31));
al.add(new Person("lisi03", 32));
al.add(new Person("lisi04", 33));
// al.add(new Person("lisi04",33));
al.add(new Person("lisi05", 34));
al = singleElement(al);
sop("singleElement():" + al);
// remove()方法底层也调用equals()方法
sop("remove 03: " + al.remove(new Person("lisi03", 32)));
Iterator it = al.iterator();
while (it.hasNext())
{
Person p = (Person) it.next();
sop(p.getName() + "::::" + p.getAge());
}
}
public static ArrayList<Person> singleElement(ArrayList<Person> al)
{
// 定义一个临时容器
ArrayList<Person> newAl = new ArrayList<Person>();
Iterator it = al.iterator();
while (it.hasNext())
{
Object obj = it.next();
// 判断元素,每一次调用contains()方法时候会调用底层的equals()方法
if (!newAl.contains(obj))
{
newAl.add((Person) obj);
}
}
return newAl;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class Person
{
private String name;
private int age;
public Person(String name, int age)
{
super();
this.name = name;
this.age = age;
}
//name和age属性的get和set方法省略
public boolean equals(Object obj)
{
// 如果传入的类型不是Person类
if (!(obj instanceof Person))
{
return false;
}
// 强制类型转换成Person类
Person per = (Person) obj;
return this.name.equals(per.name) && this.age == per.age;
}
}注：对于List集合，无论是add、contains、还是remove方法，判断元素是否相同， 都是通过复写equals方法来判断！
（3）Vector
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, SerializableVector:底层是数组数据结构，查询速度以及增删均稍慢。特点：线程同步的，相对ArrayList效率低。
1）构造方法如下所示：
Vector(): 构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
Vector(Collection<? extends E> c): 构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。2 ）方法摘要：
添加：
boolean add(E e): 将指定元素添加到此向量的末尾。
void add(int index, E element): 在此向量的指定位置插入指定的元素。
boolean addAll(Collection<? extends E> c): 将指定 Collection 中的所有元素添加到此向量的末尾， 按照指定 collection 的迭代器所返回的顺序添加这些元素。
boolean addAll(int index, Collection<? extends E> c): 在指定位置将指定 Collection 中的所有元素插入到此向量中。
获取:
Enumeration<E> elements(): 返回此向量的组件的枚举。
Vector特有的取出方式:枚举和迭代器很像，其实枚举和迭代器是一样的，只是因为枚举的名称和方法的名称。 示例代码如下所示：
public class VectorDemo
{
public static void main(String[] args)
{
// 创建Vector对象
Vector<String> v = new Vector<String>();
// 向Vector集合中添加元素
v.add("Java01");
v.add("Java02");
v.add("Java03");
v.add("Java04");
Enumeration<String> en = v.elements();
while (en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}（4）LinkedList
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable底层的数据结构是链表数据结构；特点：查询速度慢，但是增删较快
1）构造方法摘要：
LinkedList(): 构造一个空列表。
LinkedList(Collection<? extends E> c): 构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。2 ）方法摘要 :
添加
void addFirst(E e): 将指定元素插入此列表的开头。
void addLast(E e): 将指定元素添加到此列表的结尾。
获取元素，但不删除元素
E get(int index): 返回此列表中指定位置处的元素。
E getFirst(): 返回此列表的第一个元素。
E getLast(): 返回此列表的最后一个元素。
获取元素且删除元素
E remove()： 获取并移除此列表的头（第一个元素）。
E remove(int index)： 移除此列表中指定位置处的元素。
boolean remove(Object o)： 从此列表中移除首次出现的指定元素（如果存在）。
E removeFirst()： 移除并返回此列表的第一个元素。
E removeLast(): 移除并返回此列表的最后一个元素。
修改
E set(int index, E element) 将此列表中指定位置的元素替换为指定的元素。 示例代码如下所示：
/*
使用LinkedList模拟一个堆栈或者队列数据结构
堆栈：先进后出 ；队列：先进先出
*/
class DuiLie
{
private LinkedList link;
// 初始化构造函数
DuiLie()
{
link = new LinkedList();
}
// 模拟增加方法
public void myAdd(Object obj)
{
link.addFirst(obj);
}
// 模拟获取方法
public Object myGet()
{
// return link.removeLast(); //移除最后一个元素
// 移除第一个元素
return link.removeFirst();
}
// 模拟是否为空
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[] args)
{
// 实例化队列对象
DuiLie dl = new DuiLie();
// 向队列中添加元素
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
// 获取队列中元素
while (!dl.isNull())
{
System.out.println(dl.myGet());
}
}
}Set
public interface Set<E> extends Collection<E>（1）特点：元素是无序的，元素不可以重复
（2）HashSet
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, Serializable底层数据结构哈希表；如何保障元素的唯一性？通过元素的两个方法，hashCode和equals方法来完成；如果元素的hashCode值相同，才会判断equals是否为true；如果元素的hashCode值不同，不会调用equals方法
注意：对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。
1）构造方法：
HashSet() 构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。
HashSet(Collection<? extends E> c) 构造一个包含指定 collection 中的元素的新 set。2 ）方法摘要：
boolean add(E e) 如果此 set 中尚未包含指定元素，则添加指定元素。
void clear() 从此 set 中移除所有元素。
Object clone() 返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。
boolean contains(Object o) 如果此 set 包含指定元素，则返回 true。
boolean isEmpty() 如果此 set 不包含任何元素，则返回 true。
Iterator<E> iterator() 返回对此 set 中元素进行迭代的迭代器。
boolean remove(Object o) 如果指定元素存在于此 set 中，则将其移除。
int size() 返回此 set 中的元素的数量（set 的容量）。 示例代码如下所示：
/**
* 往HashSet集合中添加自定义对象 姓名和年龄相同则为同一个人，重复元素
* */
class HashSetTest
{
public static void main(String[] args)
{
HashSet<Person> hs = new HashSet<Person>();
hs.add(new Person("a1", 11));
hs.add(new Person("a2", 12));
hs.add(new Person("a3", 13));
hs.add(new Person("a4", 14));
sop("contains():" + hs.contains(new Person("a1", 12)));
hs.remove(new Person("a4", 14));
Iterator<Person> it = hs.iterator();
while (it.hasNext())
{
Person p = (Person) it.next();
sop(p.getName() + " -->" + p.getAge());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class Person
{
private String name;
private int age;
.......
public int hashCode()
{
System.out.println(this.name + "...hashCode");
return name.hashCode() + age;
}
public boolean equals(Object obj)
{
// 如果传入的类型不是Person类
if (!(obj instanceof Person))
{
return false;
}
// 强制类型转换成Person类
Person per = (Person) obj;
return this.name.equals(per.name) && this.age == per.age;
}
}（3）TreeSet
public class TreeSet<E>
extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, Serializable使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序。
1）构造方法：
TreeSet() 构造一个新的空 set，该set根据其元素的自然顺序进行排序。
TreeSet(Collection<? extends E> c) ：构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。
TreeSet(Comparator<? super E> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。2）方法摘要：
添加：
boolean add(E e) 将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。
boolean addAll(Collection<? extends E> c) 将指定 collection 中的所有元素添加到此 set 中。
删除：
void clear() 移除此 set 中的所有元素。
boolean remove(Object o) 将指定的元素从 set 中移除（如果该元素存在于此 set 中）。
E pollFirst() 获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
E pollLast() 获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
获取：
Iterator<E> iterator() 返回在此 set 中的元素上按升序进行迭代的迭代器。
E first() 返回此 set 中当前第一个（最低）元素。
E last() 返回此 set 中当前最后一个（最高）元素。
int size() 返回 set 中的元素数（set 的容量）。
判断：
boolean isEmpty() 如果此 set 不包含任何元素，则返回 true。
boolean contains(Object o) 如果此 set 包含指定的元素，则返回 true。示例代码（1）如下所示：
/*
* 将学生信息按照姓名来排序
* 定义一个类实现Comparator接口，覆盖compare方法
* */
class TreeSetDemo2
{
public static void main(String[] args)
{
TreeSet<Student> ts = new TreeSet<Student>(new MyCompare());
ts.add(new Student("lisi01", 22));
ts.add(new Student("lisi02", 11));
ts.add(new Student("lisi02", 13));
ts.add(new Student("lisi05", 34));
ts.add(new Student("lisi04", 22));
Iterator<Student> it = ts.iterator();
while (it.hasNext())
{
Student stu = (Student) it.next();
System.out.println(stu.getName() + "...." + stu.getAge());
}
}
}
class MyCompare implements Comparator
{
public int compare(Object o1, Object o2)
{
Student s1 = (Student) o1;
Student s2 = (Student) o2;
int num = s1.getName().compareTo(s2.getName());
if (num == 0)
{
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
return num;
}
}
class Student implements Comparable
{
private String name;
private int age;
.......
public int compareTo(Object obj)
{
if (!(obj instanceof Student))
{
throw new RuntimeException("不是学生对象");
}
Student stu = (Student) obj;
// 主要条件
if (this.age > stu.age)
{
return 1;
}
if (this.age == stu.age)
{
// 次要条件
return this.name.compareTo(stu.name);
}
return -1;
}
......
}示例代码（2）如下所示：
/**
* 按照字符串的长度来排序 字符串本身具备比较性，但是它的比较方式不是所需要的。 这时候只能使用比较器。
* */
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet<String> ts = new TreeSet<String>(new StringLengthCompartor());
ts.add("abcd");
ts.add("ad");
ts.add("yuphypug");
ts.add("qwerqw");
ts.add("hjk");
ts.add("abd");
Iterator<String> it = ts.iterator();
while (it.hasNext())
{
System.out.println(it.next());
}
}
}
class StringLengthCompartor implements Comparator
{
public int compare(Object o1, Object o2)
{
String s1 = (String) o1;
String s2 = (String) o2;
// 主要条件
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if (num == 0)
{
// 次要条件
return s1.compareTo(s2);
}
return num;
}
}Map
public interface Map<K,V>（1）特点
将键映射到值的对象。Map集合没有迭代器！Map集合特点：该集合存储键值对。而且键是唯一的。
（2）遍历方式
1）方法摘要：
添加：
V put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。
void putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中。
删除：
void clear() 从此映射中移除所有映射关系（可选操作）。
V remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
判断：
boolean containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。
boolean isEmpty() 如果此映射未包含键-值映射关系，则返回 true。
获取：
int size() 返回此映射中的键-值映射关系数。
Collection<V> values() 返回此映射中包含的值的 Collection 视图。重点：Map集合没有迭代器，以下是Map的两种取出方式：
第一种：Set<K> keySet()：返回此映射中包含的键的Set视图，将Map集合中所有的键存入Set集合，然后再通过Set集合的迭代器取出所有的键，再根据get方法获取每个键的值；
第二种：Set<Map.Entry<K,V>> entrySet() ：返回此映射中包含的映射关系的Set视图，将Map集合中的映射关系存入到Set集合中，
这个映射关系的数据类型是Map.entry,再通过Map.Entry类的方法再要取出关系里面的键和值。
Map.Entry的方法摘要：
boolean equals(Object o) 比较指定对象与此项的相等性。
K getKey() 返回与此项对应的键。
V getValue() 返回与此项对应的值。
int hashCode() 返回此映射项的哈希码值。
V setValue(V value) 用指定的值替换与此项对应的值(特有！！！)。示例代码（1）如下所示：
class MapDemo
{
public static void main(String[] args)
{
Map<String,String> map = new HashMap<String,String>();
//添加元素，如果添加时出现相同的键，那么后添加的值会覆盖原有键对应的值，
//并且put方法会返回被覆盖的值。
System.out.println("put:" + map.put("01","zhangsan01"));
System.out.println("put:" + map.put("01","wangwu"));
map.put("02","zhangsan02");
map.put("03","zhangsan03");
System.out.println("containskey:" + map.containsKey("022"));
//System.out.println("remove:" + map.remove("02"));
System.out.println("get:" + map.get("023"));
//可以通过get方法的返回值来判断一个键是否存在
//通过返回空来判断
map.put(null,"haha");
map.put("04",null);
System.out.println("get:" + map.get("haha"));
//获取map集合中所有的值
Collection<String> coll = map.values();
System.out.println("coll:" + coll);
System.out.println(map);
}
}示例代码（2）如下所示：
class MapDemo2
{
public static void main(String[] args)
{
Map<String, String> map = new HashMap<String, String>();
map.put("01", "zhangsan01");
map.put("02", "zhangsan02");
map.put("03", "zhangsan03");
map.put("04", "zhangsan04");
// 先将Map集合中的映射关系取出，存入到Set集合中
Set<Map.Entry<String, String>> entrySet = map.entrySet();
// 有了set集合就可以获取其迭代器
Iterator<Map.Entry<String, String>> it = entrySet.iterator();
while (it.hasNext())
{
Map.Entry<String, String> me = it.next();
// 有了键就可以通过map集合的get方法获取其对应的值
String key = me.getKey();
String value = me.getValue();
System.out.println(key + " : " + value);
}
}
}（3）HashMap
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable底层是哈希表数据结构；允许使用null键和null值；线程不同步，效率高；
保证元素唯一性的: 原理：先判断元素的hashCode值是否相同，再判断两元素的equals方法是否为true (往HashSet里面存的自定义元素要复写hashCode和equals方法， 以保证元素的唯一性！)
示例代码如下所示：
class HashMapDemo
{
public static void main(String[] args)
{
HashMap<Student, String> hm = new HashMap<Student, String>();
hm.put(new Student("lisi1", 21), "beijing");
hm.put(new Student("lisi2", 22), "shanghai");
hm.put(new Student("lisi2", 22), "shenzheng");
hm.put(new Student("lisi3", 23), "nanjing");
hm.put(new Student("lisi4", 24), "wuhan");
//使用keySet方式遍历HashMap
keySet(hm);
System.out.println("----keySet VS entrySet----");
//使用entrySet方式遍历HashMap
entrySet(hm);
}
/**
* 使用keySet方式遍历HashMap
* @param hm 需要遍历的HashMap集合
*/
private static void keySet(HashMap<Student, String> hm)
{
Set<Student> keySet = hm.keySet();
Iterator<Student> it = keySet.iterator();
while (it.hasNext())
{
Student stu = it.next();
String addr = hm.get(stu);
System.out.println(stu + "==>" + addr);
}
}
/**
* 使用entrySet方式遍历HashMap
* @param hm 需要遍历HashMap集合
*/
private static void entrySet(HashMap<Student, String> hm)
{
Set<Map.Entry<Student, String>> entrySet = hm.entrySet();
Iterator<Map.Entry<Student, String>> it = entrySet.iterator();
while (it.hasNext())
{
Map.Entry<Student, String> me = it.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu + "==>" + addr);
}
}
}
class Student implements Comparable<Student>
{
private String name;
private int age;
......
public int compareTo(Student stu)
{
int num = new Integer(this.age).compareTo(new Integer(stu.age));
if (num == 0)
{
return this.name.compareTo(stu.name);
}
return num;
}
public int hashCode()
{
return name.hashCode() + age * 13;
}
public boolean equals(Object obj)
{
if (!(obj instanceof Student))
{
throw new ClassCastException("类型不匹配");
}
Student stu = (Student) obj;
return this.name.equals(stu.name) && this.age == stu.age;
}
......
public String toString()
{
return name + ":" + age;
}
}（4）Hashtable
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, Serializable底层是哈希表数据结构；不可以使用null键和null值；用作键的对象必须实现hashCode和equals方法来保证键的唯一性。线程同步，效率低
示例代码如下所示：
class A
{
int count;
public A(int count)
{
super();
this.count = count;
}
// 根据count之来判断两个对象是否相等
@Override
public boolean equals(Object obj)
{
if (obj == this)
{
return true;
}
if (obj != null && obj.getClass() == A.class)
{
A a = (A) obj;
return this.count == a.count;
}
return false;
}
@Override
public int hashCode()
{
return this.count;
}
}
class B
{
// 重写equals()方法，B对象与任何对象通过equals()方法比较都相等
public boolean equals(Object obj)
{
return true;
}
}
public class HashtableDemo
{
public static void main(String[] args)
{
Hashtable<Object, Object> ht = new Hashtable<Object, Object>();
ht.put(new A(60000), "Java");
ht.put(new A(87563), "Java EE");
ht.put(new A(1232), new B());
System.out.println(ht);
// 只要两个对象通过equals比较返回true，
// Hashtable就认为它们是相等的value。
// 由于Hashtable中有一个B对象，
// 它与任何对象通过equals比较都相等，所以下面输出true。
System.out.println(ht.containsValue("测试字符串"));
// 只要两个A对象的count相等，它们通过equals比较返回true，且hashCode相等
// Hashtable即认为它们是相同的key，所以下面输出true。
System.out.println(ht.containsKey(new A(87563)));
// 下面语句可以删除最后一个key-value对
ht.remove(new A(1232));
// 通过返回Hashtable的所有key组成的Set集合，
// 从而遍历Hashtable每个key-value对
for (Object key : ht.keySet())
{
System.out.print(key + "---->");
System.out.print(ht.get(key) + "\n");
}
}
}（5）TreeMap
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, Serializable示例代码（1）如下所示：
/**
*需求：对学生对象的年龄进行升序排序。 因为数据是以键值对形式存在的。所以要使用可以排序的Map集合。TreeMap。
**/
class TreeMapDemo
{
public static void main(String[] args)
{
TreeMap<Student, String> tm = new TreeMap<Student, String>(new StudentNameComparator());
tm.put(new Student("blisi2", 22), "shanghai");
tm.put(new Student("lisi1", 21), "beijing");
tm.put(new Student("alisi4", 24), "wuhan");
tm.put(new Student("lisi3", 23), "nanjing");
// 先将Map集合中的映射关系取出，存入到Set集合中
Set<Map.Entry<Student, String>> entrySet = tm.entrySet();
// 有了set集合就可以获取其迭代器
Iterator<Map.Entry<Student, String>> it = entrySet.iterator();
while (it.hasNext())
{
Map.Entry<Student, String> me = it.next();
// 有了键就可以通过map集合的get方法获取其对应的值
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu + "-->" + addr);
}
}
}
class StudentNameComparator implements Comparator<Student>
{
public int compare(Student s1, Student s2)
{
int num = s1.getName().compareTo(s2.getName());
if (num == 0)
{
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
return num;
}
}示例代码（2）如下所示：
/**
* 练习："sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。希望打印结果：a(1)c(2).....
* 通过结果发现，每一个字母都有对应的次数,说明字母和次数之间有映射关系
* 注意：当发现有映射关系时，可以选择Map集合,因为Map集合中存放的就是映射关系
* 什么时候使用Map集合呢？当数据之间存在映射关系时，优先考虑Map集合
* 思路： 1，将字符串转换成字符数组，因为要对每一个字母进行操作；
* 2，定义一个Map集合，因为打印结果的字母有顺序，所以使用TreeMap集合；
* 3，遍历字符数组,将每一个字母作为键去查Map集合
* 如果返回null,将字母和1返回到Map集合中；
* 如果返回不是null，说明该字母在Map集合中已经存在并有对应次数；那么就获取该次数并进行自增，然后将该字母和自增后的次数存入到Map集合中；
* 覆盖调用原有键对应的值。 4，将Map集合中的数据编程指定字符串形式返回。
**/
class MapTest
{
public static void main(String[] args)
{
String str = charCount("sdfgzxcvasdfxcvdf");
System.out.println(str);
}
public static String charCount(String str)
{
//将字符串转换成字符数组，因为要对每一个字母进行操作
char[] chs = str.toCharArray();
TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
int count = 0;
//遍历字符数组,将每一个字母作为键去查Map集合
for (int x = 0; x < chs.length; x++)
{
if (!(chs[x] >= 'a' && chs[x] <= 'z' || chs[x] >= 'A' && chs[x] <= 'Z'))
{
// 如果不是字母则继续循环
continue;
}
Integer value = tm.get(chs[x]);
if (value != null)
{
count = value;
}
count++;
tm.put(chs[x], count);
// count每次用完之后都清零
count = 0;
}
StringBuilder sb = new StringBuilder();
// 先将Map集合中的映射关系取出，存入到Set集合中
Set<Map.Entry<Character, Integer>> entrySet = tm.entrySet();
//有了set集合就可以获取其迭代器
Iterator<Map.Entry<Character, Integer>> it = entrySet.iterator();
while (it.hasNext())
{
Map.Entry<Character, Integer> me = it.next();
有了键就可以通过map集合的get方法获取其对应的值
Character ch = me.getKey();
Integer value = me.getValue();
sb.append(ch + "(" + value + ")");
}
return sb.toString();
}
}（6）Properties
public class Properties
extends Hashtable<Object,Object>1)Properties是HashTable的子类，具备Map集合的特点，里面存储的是键值对
2)Properties是IO流合集合相结合的集合容器
3)Properties的特点是可以用于存储键值对形式的配置文件
4)构造方法：
Properties() ：创建一个无默认值的空属性列表。
Properties(Properties defaults) ：创建一个带有指定默认值的空属性列表。 5)方法摘要：
Object setProperty(String key, String value) ：调用 Hashtable 的方法 put。
String getProperty(String key) ：用指定的键在此属性列表中搜索属性。
void load(InputStream inStream) ：从输入流中读取属性列表（键和元素对）。
void load(Reader reader) ：按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
void list(PrintStream out) ：将属性列表输出到指定的输出流。
void list(PrintWriter out) ：将属性列表输出到指定的输出流。
void store(OutputStream out, String comments) ：以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
void store(Writer writer, String comments) ：以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。
Set<String> stringPropertyNames() ：返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键 示例代码（1）如下所示：
public static void show()
{
Properties prop = new Properties();
prop.setProperty("张三","26");
prop.setProperty("李四","30");
prop.setProperty("王五","35");
sop(prop);
String value = prop.getProperty("张三");
Set<String> keys = prop.stringPropertyNames();
for(String key : values)
{
sop(key+":"+prop.getPropety(key));
}
}示例代码（2）如下所示：
public class PropertiesTest
{
public static void main(String[] args) throws IOException
{
Properties prop = new Properties();// 定义Properties，用来和IO流结合
File file = new File("library\\time.ini");// 配置文件
if (!file.exists()) file.createNewFile();// 如果文件不存在则创建文件(用于第一次使用时创建文件)
FileInputStream fis = new FileInputStream(file);// 定义字节读取流，读取配置文件中记录的使用次数
prop.load(fis);// 载入流，以获取文件中配置的键值对
int count = 0;// 定义使用次数
String countValue = prop.getProperty("time");// 通过键获取值
if (countValue != null)
{// 第一次时countValue为null
count = Integer.parseInt(countValue);// 将字符串次数变成数字次数
if (count > 3)
{
System.out.println("您使用次数已到，继续使用请注册！");
return;
}
}
count++;// 如果使用次数未到则次数加1
prop.setProperty("time", count + "");// 配置新的键值对
FileWriter fos = new FileWriter(file);
prop.store(fos, "这是应用程序使用次数的配置文件");// 将新的键值对写入文件
fis.close();
fos.close();
}
}Queue
public interface Queue<E>
extends Collection<E>Queue用于模拟队列这种数据结构，队列通常是指先进先出读的容器，队列的头部保存在队列中存放时间最长的元素，队列的尾部保存在队列中存放时间最短的元素。
队列中不允许随机访问队列中的元素。
该接口中有以下几种方法：
增加：
Boolean add(E e):将指定的元素插入此队列中；
Boolean offer(E e ):将指定的元素插入到此队列中，如果使用有容量限制的队列时候，此方法通常比上一种方法更好；
获取
E element() ：获取，但是不移除此队列的头。
E peek() ：获取但不移除此队列的头；如果此队列为空，则返回 null。
E poll() ：获取并移除此队列的头，如果此队列为空，则返回 null。
删除
E remove() ：获取并移除此队列的头。 （1）PriorityQueue实现类
public class PriorityQueue<E>
extends AbstractQueue<E>
implements SerializablePriporityQueue不允许插入null元素，它还需要对队列元素进行排序，包括自然排序和定制排序。
示例代码如下所示：
public class PriorityQueueTest
{
public static void main(String[] args)
{
PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
// 向pq中依次加入四个元素
pq.add(9);
pq.add(3);
pq.add(12);
pq.add(-1);
// 输出pq队列，并不是按元素的加入顺序排列的
System.out.println(pq);
// 访问该队列的第一个元素
System.out.println(pq.poll());
}
}（2）Deque接口与ArrayDeque实现类
public interface Deque<E>extends Queue<E>Deque接口是Queue接口的子接口，它代表一个双端队列，该接口的方法如下所示：
插入
addFirst(e):将指定的元素插入该双端队列的开头；
offerFirst(e) ：将指定的元素插入该双端队列的开头；
addLast(e)：将指定的元素插入该双端队列的末尾；
offerLast(e) ：将指定的元素插入该双端队列的末尾；
移除
removeFirst() ：获取并删除该双端队列的第一个元素；
pollFirst() ：获取并删除该双端队列的第一个元素，如果此双端队列为空，则返回null;
removeLast() ：获取并删除该双端队列的最后一个元素；
pollLast() ：获取并删除该双端队列的最后一个元素，如果此双端队列为空，则返回null；
获取
getFirst() ：获取但不删除第一个元素；
peekFirst() ：获取但不删除第一个元素，但如果此双端队列为空，返回null;
getLast()：获取但不删除最后一个元素；
peekLast() ：获取但不删除最后一个元素，但如果此双端队列为空，返回null;public class ArrayDeque<E>
extends AbstractCollection<E>
implements Deque<E>, Cloneable, SerializableArrayDeque类是一个基于数组实现的双端队列，创建Deque时同样可指定一个numElements参数，该参数用于指定Object[]数组的长度；如果不制定numElements参数，Deque底层的数据长度是16.
示例代码如下所示：
public class ArrayDequeTest
{
public static void main(String[] args)
{
ArrayDeque<String> stack = new ArrayDeque<String>();
// 依次向stack中插入三个元素
stack.push("Java");
stack.push("Java Web");
stack.push("Java EE");
// 输出
System.out.println("stack : " + stack);
}
}其它常用类
工具类
（1）Arrays
public class Arrays
extends Object此类包含用来操作数组（比如排序和搜索）的各种方法。里面都是静态方法。
如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。
1)静态方法摘要：
static <T> List<T> asList(T... a):返回一个受指定数组支持的固定大小的列表。
注意：
A:该方法将一个数组变成集合后，不可以使用集合的增删方法，因为数组的长度是固定的！ 如果增删，则发生UnsupportedOprationException(不支持操作异常)；
B:如果数组中的元素都是基本数据类型，则该数组变成集合时，会将该数组作为集合的一个元素出入集合；
C:如果数组中的元素都是对象，如String，那么数组变成集合后，数组中的元素就直接转成集合中的元素。
示例代码如下所示：
class ArraysDemo
{
public static void main(String[] args)
{
int[] arr = { 2, 3, 1234, 23, 45, 89, 87 };
// 使用toString方法将数组输出
System.out.println(Arrays.toString(arr));
String[] strArr = { "abc", "cc", "kkll" };
List<String> list = Arrays.asList(strArr);
// list.add("aa");
// 会引发java.lang.UnsupportedOperationException
sop("contains:" + list.contains("cc"));
sop(list);
/*
* 如果数组中的元素都是对象，那么变成集合时， 数组中元素就转换成集合中的元素 如果数组中的元素都是基本数据类型，那么会将该数组
* 作为集合中的元素存在。
*/
Integer[] nums = { 2, 3, 1234, 23, 45, 89, 87 };
// asList:将数组变成List集合
List<Integer> li = Arrays.asList(nums);
sop(li);
}
public static boolean myContains(String[] arr, String key)
{
for (int x = 0; x < arr.length; x++)
{
if (arr[x].equals(key))
{
return true;
}
}
return false;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}（2）Collections
public class Collections
extends Object此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
1)静态方法摘要：
static <T> boolean addAll(Collection<? super T> c, T... elements) ：将所有指定元素添加到指定 collection 中。
static <T> void fill(List<? super T> list, T obj) ：使用指定元素替换指定列表中的所有元素。
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) ：使用另一个值替换列表中出现的所有某一指定值。
static void reverse(List<?> list) ：反转指定列表中元素的顺序。
static <T> Comparator<T> reverseOrder() ：返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序
static <T> Comparator<T> reverseOrder(Comparator<T> cmp) ：返回一个比较器，它强行逆转指定比较器的顺序。 2)Collections 类方法：集合有一个共同的缺点，那就是线程不安全，被多线程操作时，容易出现问题，虽然可以自己加锁，但是麻烦。Collections提供特牛的方法，就是给它一个不同步的集合，它返回一个同步的安全的集合。
static <T> Collection<T> synchronizedCollection(Collection<T> c) ：返回指定 collection 支持的同步（线程安全的）collection。
static <T> List<T> synchronizedList(List<T> list) ：返回指定列表支持的同步（线程安全的）
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) ：返回由指定映射支持的同步（线程安全的）映射。
static <T> Set<T> synchronizedSet(Set<T> s) ：返回指定 set 支持的同步（线程安全的）set。
static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)：返回指定有序映射支持的同步（线程安全的）有序映射。
static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)：返回指定有序 set 支持的同步（线程安全的）有序 set。 示例代码（1）如下所示：
class CollectionsDemo
{
public static void main(String[] args)
{
sortDemo();
maxDemo();
binarySearchDemo();
}
/**
* 通过指定比较器实现二分查找
* */
public static int halfSearch(List<String> list, String key, Comparator<String> cmp)
{
int max, min, mid;
max = list.size() - 1;
min = 0;
while (min <= max)
{
mid = (min + max) / 2;
String str = list.get(mid);
int num = cmp.compare(str, key);
if (num > 0)
max = mid - 1;
else if (num < 0)
min = mid + 1;
else return mid;
}
return -min - 1;
}
/**
* 通过关键字实现二分查找
* */
public static int halfSearch(List<String> list, String key)
{
int max, min, mid;
max = list.size() - 1;
min = 0;
while (min <= max)
{
mid = (min + max) / 2;
String str = list.get(mid);
int num = str.compareTo(key);
if (num > 0)
max = mid - 1;
else if (num < 0)
min = mid + 1;
else return mid;
}
return -min - 1;
}
public static void binarySearchDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("dfasdfcd");
list.add("secfcd");
list.add("cc");
list.add("qewrd");
list.add("qewrd");
list.add("iopip");
// 使用二分查找指定的元素
int index = halfSearch(list, "cc");
sop("使用二分查找指定的元素： " + index);
}
/**
*获取集合中最大元素
* */
public static void maxDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("dfasdfcd");
list.add("secfcd");
list.add("qewrd");
list.add("qewrd");
list.add("iopip");
// 打印出来
sop("原集合中元素为:" + list);
// 使用sort方法对元素进行排序
Collections.sort(list);
sop("使用sort方法排序后集合中元素为：" + list);
// 通过指定自定义比较器后获取最大元素
String max = Collections.max(list, new StringLengthComparator());
sop("通过指定自定义比较器后获取最大元素: " + max);
}
/**
* 演示排序功能
* */
public static void sortDemo()
{
// 实例化List对象
List<String> list = new ArrayList<String>();
// 向list集合中添加元素
list.add("abcd");
list.add("dfasdfcd");
list.add("secfcd");
list.add("qewrd");
list.add("qewrd");
list.add("iopip");
// 打印出来
sop("原集合中元素为:" + list);
Collections.swap(list, 1, 2);
// 交换后list集合中元素
sop("交换元素后集合中元素为:" + list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
// 指定比较器来比较
class StringLengthComparator implements Comparator<String>
{
public int compare(String s1, String s2)
{
if (s1.length() > s2.length())
{
return 1;
}
if (s1.length() < s2.length())
{
return -1;
}
return s1.compareTo(s2);
}
}运行结果如下所示：
示例代码（2）如下所示：
class CollectionsDemo2
{
public static void main(String[] args)
{
fillDemo();
replaceAllDemo();
orderDemo();
shuffleDemo();
}
public static void shuffleDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("secfcd");
list.add("cc");
list.add("dfasdfcd");
sop("--------shuffleDemo--------");
sop("原集合中元素为：" + list);
Collections.shuffle(list);
sop("使用shuffle排序后集合中元素为： " + list);
}
public static void orderDemo()
{
TreeSet<String> ts = new TreeSet<String>(new StrComparator());
ts.add("abcde");
ts.add("aaa");
ts.add("kk");
ts.add("ccccadfa");
Iterator it = ts.iterator();
sop("--------orderDemo--------");
while (it.hasNext())
{
sop(it.next());
}
}
public static void replaceAllDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("dfasdfcd");
list.add("secfcd");
list.add("cc");
sop("--------replaceAllDemo--------");
sop("原集合中元素为：" + list);
Collections.replaceAll(list, "cc", "pp");
sop("使用replaceAll方法后集合中元素为： " + list);
Collections.reverse(list);
sop("使用reverse方法后集合中元素为： " + list);
}
public static void fillDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("dfasdfcd");
list.add("secfcd");
list.add("cc");
sop("--------fillDemo--------");
sop("原集合中元素为：" + list);
Collections.fill(list, "pp");
sop("使用fill方法后集合中元素为： " + list);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class StrComparator implements Comparator<String>
{
public int compare(String s1, String s2)
{
return s2.compareTo(s1);
}
}运行结果如下所示：
(1)为了更方便的操作每个基本数据类型，java对其提供了很多的属性和方法供我们使用。
(2)用途：
将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能操作该数据。
常用的操作之一：用于基本数据类型与字符串之间的转换。
A:方便操作
B:用于和字符串进行相互转换
(3)基本数据类型和对象类型的对应
byte:Byte
short:Short
int:Integer
long:Long
float:Float
double:Double
boolean:Boolean
char:Character
(4)构造方法
字段摘要：
static int MAX_VALUE 值为 2^31-1 的常量，它表示 int 类型能够表示的最大值
static int MIN_VALUE 值为 -2^31 的常量，它表示 int 类型能够表示的最小值
static Class<Integer> TYPE 表示基本类型int的Class 实例
Integer(int value) 构造一个新分配的Integer对象，它表示指定的int值。
Inreger(String s) 注意：s必须是纯数字的字符串。否则会有异常NumberFormatException
(5) 几个常用的方法
Integer.toBinaryString()：以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
Integer.toOctalString()：以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。
Integer.toHexString()：以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
static int Integer.parseInt(String s)：将字符串参数作为有符号的十进制整数进行解析,字符串必须是int型范围内的数字字符串
static int Integer.parseInt(String s,int basic) ：使用第二个参数指定的基数,将字符串参数解析为有符号的整数.字符串必须是int型范围内的数字字符串
short shortValue() 以short类型返回该Integer的值。
int intValue() 以int类型返回该Integer的值。
static Integer valueOf(int num) 返回一个表示指定的 int 值的 Integer 实例。
static Integer valueOf(String s) 返回保存指定的String的值的Integer对象。
static Integer valueOf(String s, int radix) ：返回一个Integer对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的String中提取的值。 系统类
（1）System类
public final class System
extends Object描述系统信息的类，该类没有构造方法，该类的方法和属性都是静态的。
1)字段摘要：
static InputStream in “标准”输入流。
static PrintStream out “标准”输出流。 2) 方法摘要：
static void exit(int status) 终止当前正在运行的 Java 虚拟机。
static void gc() 运行垃圾回收器。
static Properties getProperties() 确定当前的系统属性
static String getProperty(String key) 获取指定键指示的系统属性。
static String getProperty(String key, String def) 获取用指定键描述的系统属性。
static void setIn(InputStream in) 重新分配“标准”输入流。
static void setOut(PrintStream out) 重新分配“标准”输出流。
static void setProperties(Properties props) 将系统属性设置为 Properties 参数。
static String setProperty(String key, String value) 设置指定键指示的系统属性。示例代码如下所示：
public class SystemTest
{
public static void main(String[] args) throws Exception
{
// 获取系统的所有环境变量
Map<String, String> envs = System.getenv();
for (String name : envs.keySet())
{
System.out.println(name + "-->" + envs.get(name));
}
// 获取指定的环境变量
System.out.println("Java_home: " + System.getenv("Java_home"));
// 获取所有的系统属性
Properties prop = System.getProperties();
// 将所有的属性存放在source目录下的props.properties文件中
prop.store(new FileOutputStream("source//props.properties"), "System properties");
// 获取指定的系统属性
System.out.println("os.name" + System.getProperty("os.name"));
}
}（2）Runtime类
public class Runtime
extends Object每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。 应用程序不能创建自己的 Runtime 类实例。
1)该类没有构造函数，也就是它不能直接创建对象，但是它里里面的方法又不是静态的 ，故它一定有一个方法返回本类对象，因此该类是单例设计模式，保证在内存中只有一个对象
2)方法摘要：
Process exec(String command) 在单独的进程中执行指定的字符串命令
void gc() 运行垃圾回收器。
static Runtime getRuntime() 返回与当前 Java 应用程序相关的运行时对象
void exit(int status) 通过启动虚拟机的关闭序列，终止当前正在运行的 Java 虚拟机示例代码如下所示：
public class RuntimeTest
{
public static void main(String[] args)
{
// 获取Java程序关联的运行时对象
Runtime rt = Runtime.getRuntime();
System.out.println("处理器数量： " + rt.availableProcessors());
System.out.println("空闲内存数：" + rt.freeMemory());
System.out.println("总内存数：" + rt.totalMemory());
System.out.println("最大可用内存数：" + rt.maxMemory());
// 运行记事本程序
try
{
rt.exec("notepad.exe");
}
catch (IOException e)
{
e.printStackTrace();
}
}
}时间类
（1）Date类
public class Date
extends Object
implements Serializable, Cloneable, Comparable<Date>Date类表示特定的瞬间，精确到毫秒
1）构造方法
Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
Date(long date) 分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00GMT）以来的指定毫秒数。2） 方法摘要：
int compareTo(Date anotherDate) 比较两个日期的顺序。
boolean equals(Object obj) 比较两个日期的相等性。示例代码如下所示：
class DateDemo
{
public static void main(String[] args)
{
Date date = new Date();
System.out.println("date :" + date);
// 打印的时间看不懂，希望有些格式
// 将模式封装到SimpleDateFormat中
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 w周E hh:mm:ss");
// 调用format方法让模式格式化指定Date对象
String time = sdf.format(date);
System.out.println("time:" + time);
}
}（2）Calendar类
public abstract class Calendar
extends Object
implements Serializable, Cloneable, Comparable<Calendar>1）构造方法：
protected Calendar() 构造一个带有默认时区和语言环境的 Calendar。
protected Calendar(TimeZone zone, Locale aLocale) 构造一个带有指定时区和语言环境的 Calendar。
2）方法摘要：
static Calendar getInstance() 使用默认时区和语言环境获得一个日历。示例代码如下所示：
class CalendarDemo
{
public static void main(String[] args)
{
Calendar c = Calendar.getInstance();
sop(c.get(Calendar.YEAR) + "年");
sop(c.get(Calendar.MONTH) + 1 + "月");
sop(c.get(Calendar.DATE) + "日");
sop("星期" + (c.get(Calendar.DAY_OF_WEEK) - 1));
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}（3）TimeZone类
public abstract class TimeZone
extends Object
implements Serializable, CloneableTimeZone是一个抽象类，不能调用其构造器来创建实例，可以通过调用其静态方法得到TimeZone实例。
示例代码如下所示：
public class TimeZoneTest
{
public static void main(String[] args)
{
//取得Java所支持的所有时区ID
String [] ids = TimeZone.getAvailableIDs();
System.out.println(Arrays.toString(ids));
//获取系统默认时区的ID
TimeZone defaultID = TimeZone.getDefault();
//获取系统默认时区的名称
String defaultName = defaultID.getDisplayName();
System.out.println(defaultID +"-->"+ defaultName);
}
}
扫一扫
693
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
