Java第六章 实用类及接口
字符串处理
java.lang 包中有两个处理字符串的类 String 和 StringBuffer。String 类描述固定长度的字符串，其内容是不变的，适用于字符串常量。StringBuffer 类描述长度可变且内容可变的字符串，适用于需要经常对字符串中的字符进行各种操作的字符串变量。
java.util包中有个StringTokenizer类，它可以通过分割符来分解字符串。
STRING
valueOf() 方法通常用于将字符串转换为特定类型的对象。
String numberStr = "123";
Integer number = Integer.valueOf(numberStr);
System.out.println(number); // 输出：123
length()和
charAt()
String str = "Hello";
char ch = str.charAt(1); // 获取索引为1的字符，即 'e'
System.out.println(ch); // 输出：e
和getChar()
s1.getChars( 0, 5, charArray, 0 );//调用String类的getChars方法
开始，结束，字符串，间隔
字符串截取和定位，indexOf（），substring（）
class SubStringExample{
public static void main(String[] args) {
String s="hello Java语言";
int n1=s.indexOf('a');
int n2=s.indexOf("a语");
System.out.println("n1="+n1+" n2="+n2);
char c=s.charAt(2);
String s1=s.substring(6,10);
String s2=s.substring(4,7);
System.out.println("c="+c+" s1="+s1+" s2="+s2);
}
}
substring(int beginIndex)：这个版本的 substring() 方法从指定的 beginIndex 开始，直到字符串的末尾。
String str = "Hello, World!";
String sub = str.substring(7); // 从索引 7（包括）开始提取子字符串
System.out.println(sub); // 输出：World!
substring(int beginIndex, int endIndex)：substring() 方法从 beginIndex 开始，并在 endIndex（不包括）结束。
String str = "Hello, World!";
String sub = str.substring(0, 5); // 从索引 0（包括）开始到索引 5（不包括）结束
System.out.println(sub); // 输出：Hello
字符串比较方法的应用，equals(),compareTo()
if ( s1.equals( "hello" ) ) //调用String类的equals方法判断字符串是否相等
//调用String类的compareTo方法进行两字符串的大小比较
System.out.println("s1.compareTo( s2 ) is " + s1.compareTo( s2 ) +
StringBuffer
StringBuffer 是 Java 中用于创建可变字符串的类。与 String 不同，StringBuffer 允许你修改其内容而不创建新的字符串对象，这对于频繁地进行字符串操作（如添加、插入、删除等）是非常高效的。
capacity()
StringBuffer 中的 capacity() 方法返回当前 StringBuffer 对象的容量。容量是指 StringBuffer 对象内部存储字符的总量，而不是字符串的长度。
class StringBufferExample{
public static void main(String args[]) {
StringBuffer sb = new StringBuffer("Hello");
System.out.println("buffer = " + sb);
System.out.println("length = " + sb.length());
System.out.println("capacity = " + sb.capacity());
}
}
setCharAt(int index, char ch)
可以修改 StringBuffer 对象中特定位置的字符内容。
class CharAtExample {
public static void main(String args[]) {
StringBuffer sb = new StringBuffer("Hello");
System.out.println("buffer before = " + sb);
System.out.println("charAt(1) before = " + sb.charAt(1));
sb.setCharAt(1, 'i');
sb.setLength(2);
System.out.println("buffer after = " + sb);
System.out.println("charAt(1) after = " + sb.charAt(1));
}
}
append()和insert()方法
append()用于在字符序列的末尾追加内容。
StringBuffer sb = new StringBuffer("Hello");
// 追加一个字符
sb.append(' ');
// 追加一个字符串
sb.append("World");
// 追加一个整数
sb.append(123);
System.out.println(sb); // 输出：Hello World123
insert()用于在指定位置插入内容。
StringBuffer sb = new StringBuffer("Hello");
// 在索引为 5 的位置插入空格
sb.insert(5, ' ');
// 在索引为 6 的位置插入字符串 "Java"
sb.insert(6, "Java");
System.out.println(sb); // 输出：Hello Java
delete()和deleteCharAt()方法
delete(int start, int end) 方法:
- 这个方法用于删除从
start索引到end-1索引的字符序列。 -
StringBuffer sb = new StringBuffer("HelloWorld"); sb.delete(5, 10); // 删除从索引 5 到 9 的字符，结果是 "Hello" System.out.println(sb); // 输出：HellodeleteCharAt(int index)方法: - 这个方法用于删除指定索引位置的字符。
-
deleteCharAt(int index) 方法: 这个方法用于删除指定索引位置的字符。replace()方法
-
从索引replace(int start, int end, String str):start（包括）开始到索引end（不包括）结束的字符会被字符串str替换。 -
StringBuffer sb = new StringBuffer("HelloWorld"); sb.replace(5, 10, "Java"); // 替换从索引 5 到 9 的字符为 "Java" System.out.println(sb); // 输出：HelloJavareverse()方法
-
使用
StringBuffer的reverse()方法: -
StringBuffer sb = new StringBuffer("Hello"); sb.reverse(); // 反转字符串 System.out.println(sb); // 输出：olleHStringTokenizer（）
- 默认情况下，
StringTokenizer使用空格作为分隔符，所以上述代码将字符串 "Hello World Java" 分割成三个标记："Hello", "World", 和 "Java"。 -
StringTokenizer tokenizer = new StringTokenizer("Hello World Java");指定自定义分隔符: 你也可以指定其他的分隔符来初始化
StringTokenizer。
获取下一个标记: 使用 hasMoreTokens() 和 nextToken() 方法来迭代获取字符串中的标记。
while (tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken();
System.out.println(token);
}
split() 方法
String str = "Hello-World-Java";
String[] tokens = str.split("-");
for (String token : tokens) {
System.out.println(token);
}
时间及日期处理
在Java应用开发中，对时间的处理是很常见的。Java提供了三个日期类：Date、Calendar和DateFormat（格式）。在程序中，对日期的处理主要是如何获取、设置和格式化，Java的日期类提供了很多方法以满足程序员的各种需要。Date和Calendar类在java.util包中，DateFormat类在java.text包中，所以在使用前程序必须引入这两个包。
date类
import java.util.Date;
public class DateExample {
public static void main(String[] args) {
Date currentDate = new Date(); // 创建一个表示当前日期和时间的 Date 对象
System.out.println(currentDate);
}
}
Calendar类
获取 Calendar 实例: 你不能直接实例化 Calendar 类，但可以使用其子类 GregorianCalendar 来获取实例。
Calendar calendar = Calendar.getInstance(); // 获取默认时区的 Calendar 实例
import java.util.Calendar;
class CalendarExample {
public static void main(String args[]) {
String months[] = {
"Jan", "Feb", "Mar", "Apr",
"May", "Jun", "Jul", "Aug",
"Sep", "Oct", "Nov", "Dec"};
//创建Calendar对象
Calendar calendar = Calendar.getInstance();
//显示日期信息
System.out.print("Date: ");
System.out.print(months[calendar.get(Calendar.MONTH)]);
System.out.print(" " + calendar.get(Calendar.DATE) + " ");
System.out.println(calendar.get(Calendar.YEAR));
System.out.print("Time: ");
System.out.print(calendar.get(Calendar.HOUR) + ":");
System.out.print(calendar.get(Calendar.MINUTE) + ":");
System.out.println(calendar.get(Calendar.SECOND));
calendar.set(Calendar.HOUR, 10);
calendar.set(Calendar.MINUTE, 29);
calendar.set(Calendar.SECOND, 22);
System.out.print("Updated time: ");
System.out.print(calendar.get(Calendar.HOUR) + ":");
System.out.print(calendar.get(Calendar.MINUTE) + ":");
System.out.println(calendar.get(Calendar.SECOND));
}
}
SimpleDateFormat类
先创建SimpleDateFormat的一个实例，创建的时候要指定格式。然后把一个Date类的实例通过format（Date）方法传进去。然后就可以print出来。
Date date = new Date();
SimpleDateFormat sdf;
sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
System.out.println(sdf.format(date));
sdf = new SimpleDateFormat("hh:mm:ss");
System.out.println(sdf.format(date));
sdf = new SimpleDateFormat("dd MMM yyyy hh:mm:ss zzz");
System.out.println(sdf.format(date));
sdf = new SimpleDateFormat("E MMM dd yyyy");
System.out.println(sdf.format(date));
DateFormat类和SimpleDateFormat类一样
集合（Collection）框架和泛型
Java 的 Collection 接口是 Java 集合框架的根接口，定义了一组通用的操作和行为，以便对对象进行集合操作。集合框架为数据结构（如列表、集、映射等）提供了统一的接口和实现。
基本方法:
Collection接口定义了集合框架中的基本方法，如add(Object obj),remove(Object obj),contains(Object obj)等。
主要子接口和实现:
- 子接口:
List,Set,Queue, 和Deque都是Collection的子接口，每个子接口都有其特定的实现和行为。 - 实现类: Java 提供了多个实现
Collection接口的类，例如：ArrayList,LinkedList,HashSet,TreeSet,HashMap,TreeMap等。
特点:
- 有序 vs 无序:
List是有序的（它保留元素的插入顺序），而Set是无序的（它不保证元素的顺序，但确保元素的唯一性）。 - 重复元素:
List允许重复元素，而Set不允许重复元素。 - 键值对:
Map是一种特殊的集合，它存储键值对，并提供了通过键快速查找值的功能。Map中不能有重复的key。其拥有自己的内部排列机制。 - （Collection接口中的元素没有特定的顺序，元素也可以重复。）
常用方法: Collection 接口定义了一系列方法来管理集合中的元素，例如：
add(E e): 将指定的元素添加到集合中（如果成功则返回true）。remove(Object o): 从集合中移除指定的元素（如果存在）。contains(Object o): 如果集合包含指定的元素，则返回true。size(): 返回集合中的元素数量。isEmpty(): 如果集合不包含任何元素，则返回true。clear(): 从集合中移除所有元素。
并发性: Java 也提供了线程安全的集合实现，如 Collections.synchronizedList(), Collections.synchronizedSet(), 和 Collections.synchronizedMap()，以便在多线程环
泛型
在创建时加个尖括号 <> 里面放具体类型。
List创建Arraylist
在集合框架中有两种常用的List实现类：ArrayList和LinkedList。如果要支持随机访问，而不必在除尾部外的任何位置插入或除去元素，那么可以使用ArrayList。如果不需要频繁地从列表的中间位置添加和除去元素，而只要顺序地访问列表元素，那么，LinkedList实现类更好。
LinkedList
创建方法跟Arraylist一样
Set接口的HashSet类的使用（无序不可重复）
Set set = new HashSet();
set.add(new Integer(5));
set.add("abc");
set.add(new Double(1.2));
// set.add(new Integer(5));
// set.add("abc");
说明了不能重复。
泛型：
Set接口的TreeSet类的使用
TreeSet 是 Java 集合框架中的一个类，它实现了 Set 接口并使用红黑树数据结构来存储元素。与 HashSet 不同，TreeSet 提供了一种有序集合，这意味着它会根据元素的自然顺序（如果元素实现了 Comparable 接口）或者通过构造函数提供的 Comparator 接口来排序元素。
创建TreeSet的时候必须要传个排序方式进去 这里用的是Comparator 的reverseOrder() 逆向排序。
（结果）
这也是个逆序。
Iterator接口（通过 数据实例.来创建实例对象）
Iterator 接口是 Java 集合框架中的一个核心接口，它允许你按顺序访问集合（如列表、集或映射）中的元素，而不必知道集合内部的实现细节。通过 Iterator，你可以检索、移除和迭代集合中的元素。
boolean hasNext(): 如果迭代器还有更多的元素要遍历，则返回true。E next(): 返回迭代器的下一个元素，并将迭代器的状态前移
import java.util.*;
public class Main{
public static void main(String argv[]){
List list = new LinkedList();
list.add("abc");
list.add(new Integer(3));
list.add(new Boolean(true));
list.add(new Integer(3));
System.out.println(list);
Iterator it = list.iterator();
while (it.hasNext())
System.out.println(it.next());
it.remove();
}
}输出：abc 3 true 3
Map接口
Map接口不是Collection接口的继承。Map跟Set和List不同的地方在于，Map存放数据时，需要有个关键值（key），这个关键值会对应到一个指定的数据（value）。键的唯一性: 在一个 Map 对象中，每个键都必须是唯一的。但是，不同的键可以映射到相同的值。
Object put(Object key, Object value)：将互相关联的一个关键字与一个值放入该映像。
Object get(Object key)：获得与关键字key相关的值，并且返回与关键字key相关的对象。
Object remove(Object key)：从映像中删除与key相关的映射。
boolean containsValue(Object value)：判断映像中是否存在值value。
void clear()：从映像中删除所有映射。
有HashMap和TreeMap。
HashMap：
Math类
java.lang.Math 类在 Java 标准库中提供了许多用于执行基本数学运算的方法。这个类提供了静态方法，因此你可以直接通过类名调用这些方法，而无需创建 Math 类的实例。
int maxVal = Math.max(5, 7); // 输出结果为 7
Random类
在 Java 中，java.util.Random 类提供了生成随机数的功能。Random 类的对象可以用来生成不同类型的随机数，如整数、浮点数和布尔值等。
使用 nextInt() 方法生成一个随机整数。
int randomNumber = random.nextInt(); // 返回一个随机的整数
如果你想生成一个在特定范围内的随机整数，可以使用 nextInt(int bound) 方法。
int randomNumberInRange = random.nextInt(100); // 返回一个在 [0, 100) 范围内的随机整数
使用 nextDouble() 方法生成一个 [0.0, 1.0) 之间的随机浮点数。
double randomDouble = random.nextDouble(); // 返回一个随机的双精度浮点数
创建random对象实例，然后通过 eg. int i=实例.nextInt(); 来给i赋随机值。
设置随机种子
！！
“设置随机种子”的概念：
随机数生成器（如 java.util.Random）实际上并不是真正的“随机”数生成器。它们是基于某种算法的“伪随机”数生成器。为了“随机”地生成数字，这些生成器从一个起始点开始，并按照某个算法产生一系列数字。但是，每次你运行程序或创建一个新的随机数生成器对象时，这个“起始点”都是不同的，因此生成的数列看起来像是随机的。
现在，这里就有一个问题：如果我想复现某次运行中的随机数序列怎么办？这时，“种子”就派上用场了。
随机种子：种子是随机数生成器算法的一个起始值。如果你为随机数生成器设置了一个特定的种子，那么每次使用该种子来初始化随机数生成器时，它都会从相同的起始点开始生成相同的随机数序列。
创建过程：
可以在创建random实例对象的时候给seed值
也可以使用 setSeed(long seed) 方法设置随机种子。
Random random = new Random();
// 设置种子为 123456
random.setSeed(123456L);老师课件例子：
特殊！：在这里 i1和i2不相等，是因为尽管为 r1 和 r2 设置了相同的种子 1234567890L，但由于r1都调用了 nextBoolean()影响随机数生成器的内部状态。这意味着在r1调用nextBoolean()之后，随机数生成器的状态会改变，导致 r1 和 r2 产生的后续随机数不再相同。
package sample;
import java.util.Arrays;
public class ArraysTest {
public static void main(String args[]) {
int[] a1 = new int[] { 1, 2, 3, 4 };
int[] a2 = new int[] { 1, 2, 3, 4 };
// 1、比较方法
System.out.println("a1==a2?:" + Arrays.equals(a1, a2));// 比较数组元素
// 2、复制方法copyOf、copyOfRange
int[] b1 = Arrays.copyOf(a1, 5);// 复制a1数组，产生新数组b，未赋值的元素后面补0
int[] b2 = Arrays.copyOfRange(a1, 2, 4);// 有范围复制,前闭后开
// 3、toString方法
System.out.println("b1：" + Arrays.toString(b1));
System.out.println("b2：" + Arrays.toString(b2));
// 4、赋值方法fill
Arrays.fill(b1, 0, 2, 5); // 有范围赋值，表示将[0,2)之间的元素赋值为5
Arrays.fill(b2, 5); // 全部赋值，b2所有元素赋值为5
System.out.println("有范围赋值--b1：" + Arrays.toString(b1));
System.out.println("全部赋值--b2：" + Arrays.toString(b2));
// 5、排序方法sort，默认升序
Arrays.sort(b1, 0, 4); // 有范围排序，排序[0,4)之间的元素
System.out.println("有范围排序--b1：" + Arrays.toString(b1));
Arrays.sort(b1);// 全排序
System.out.println("全排序--b1：" + Arrays.toString(b1));
// 查询方法binarySearch，数组必须已经是升序排列，如果存在值，则返回该值，若不存在，返回负数
System.out.println(Arrays.binarySearch(b1, 4)); // 全部搜索，搜索数组中元素
System.out.println(Arrays.binarySearch(b1, 0, 3, -13)); // 有范围搜索，搜索数组中[0,3)之
间的元素
}
}