someClasses

xiaoxiao2021-02-28 103

一、 System

java.lang 类 System

java.lang.Object

java.lang.System

public final class System

extends Object

System 类包含一些有用的类字段和方法。它不能被实例化。

在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。

static PrintStream

err “标准”错误输出流。

static InputStream

in “标准”输入流。

static PrintStream

out “标准”输出流。

static void

exit(int status) 终止当前正在运行的 Java 虚拟机。

例子：

public voidtest1(){ System.out.println("haha"); System.err.println("hahah"); System.out.println("hhh"); //实际开发中不要混合使用err和out流 System.exit(1); System.exit(0); }

二、基本数据类型的包装类

Java是面向对象的，为了便于利用对象思维操作基本数据类型，java提供了对于基本数据类型的包装类，即每个基本类型对应相应的类。实际使用中，java提供的自动装箱和拆箱机制，使得基本类型及其包装类自由转换。集合不可以存放基本数据类型的数据，包装类，使得基本数据类型可以转换后，存入集合。

8种基本数据类型及其对应的封装类

基本数据类型

byte

short

int

long

float

double

char

boolean

封装类

Byte

Short

Integer

Long

Float

Double

Char

Boolean

主要以Integer为例，说明用法

java.lang 类 Integer

java.lang.Object

java.lang.Number

java.lang.Integer

所有已实现的接口： Serializable, Comparable<Integer>

public final class Integer

extends Number

implements Comparable<Integer>

Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。

此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

实现注意事项：“bit twiddling”方法（如 highestOneBit和 numberOfTrailingZeros）的实现基于 Henry S. Warren, Jr.撰写的 Hacker's Delight（Addison Wesley, 2002）中的一些有关材料。

1. Field

static int

MAX_VALUE 值为 231－1 的常量，它表示 int 类型能够表示的最大值。

static int

MIN_VALUE 值为－231 的常量，它表示 int 类型能够表示的最小值。

static int

SIZE 用来以二进制补码形式表示 int 值的比特位数。

static Class<Integer>

TYPE 表示基本类型 int 的 Class 实例。

例子：

System.out.println(Integer.MAX_VALUE); System.out.println(Integer.MIN_VALUE); System.out.println(Integer.SIZE);

2. Constructor

Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。

Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。

Integer in=new Integer(10); System.out.println(in); in=newInteger("100"); System.out.println(in);

3. 数字进制转换

static String

toBinaryString(int i) 以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。

static String

toHexString(int i) 以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。

static String

toOctalString(int i) 以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。

System.out.println(Integer.toBinaryString(10)); System.out.println(Integer.toOctalString(20)); System.out.println(Integer.toHexString(40));

4. 基本类型和包装类的转换

1) 包装类—转》》基本类型

int

intValue() 以 int 类型返回该 Integer 的值。

long

longValue() 以 long 类型返回该 Integer 的值。

int

intValue() 以 int 类型返回该 Integer 的值。

long

longValue() 以 long 类型返回该 Integer 的值。

int

intValue() 以 int 类型返回该 Integer 的值。

long

longValue() 以 long 类型返回该 Integer 的值。

2) 基本类型—转》》包装类

static Integer

valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。

例子：

Integer in2=new Integer(1234); int i1=in2.intValue(); System.out.println(i1); int i2=22; Integer in3=Integer.valueOf(i2); System.out.println(in3);

注意：jdk1.5之后，提供了基本数据类型的自动装箱（转化为封装类）和自动拆箱（封装类转化为基本类型）的支持。

int i3=new Integer(12); Integerin4=12;

5. 基本类型和字符串类型的转换

1) 基本类型—》》字符串类型

3种方法，据说效率从高到低位：Integer.toString()高于String.valueOf()高于+””

String s1=i4+""; String s2=String.valueOf(i4); String s3=Integer.toString(i4);

2) 字符串类型—》》基本类型

String s4="1234"; int i5=Integer.parseInt(s4);//注意参数不可以混合非数字字符，否则运行期报数字格式异常。 System.out.println(i5);

6. 包装类型和字符串类型的转换

1) 包装类型—》》字符串类型

方法同基本数据类型转字符串类型

Integer i6=new Integer(123); String s5=i6+""; System.out.println(s5); String s6=String.valueOf(i6); String s7=Integer.toString(i6); System.out.println(s6); System.out.println(s7);

2) 字符串类型—》》包装类型

使用包装类的构造函数。

Integeri6=new Integer("123");

7. 包装类的缓存

自动装箱和自动拆封，实际上底层是执行了，比如Integer时，Integer.valueOf()和Integer.intValue()。然而，为了提高运算，Integer在执行静态方法valueOf时，会判断参数的值，如果在-128—127之间，就使用静态缓存类，这个缓存类对象是固定的，区别是对象中的数值，所以，直接比较这个静态缓存类，在对象中的值相等的情况下，可以得到相等。如果参数不在这个-127和128之间，则新建Integer对象，所以，即使新建的对象中值相等，但是==比较的是对象的hash地址，所以结果为false。

Integer中相关的底层代码

8位2进制补码缓存，即1个字节的缓存。

private static class IntegerCache { static final int low= -128; static final int high; static final Integer cache[]; static { // high value may be configured by property int h = 127; String integerCacheHighPropValue = sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high"); if (integerCacheHighPropValue != null){ int i = parseInt(integerCacheHighPropValue); i = Math.max(i, 127); // Maximum array size is Integer.MAX_VALUE h = Math.min(i, Integer.MAX_VALUE - (-low) -1); } high = h; cache = new Integer[(high - low)+ 1]; int j = low; for(int k = 0; k < cache.length; k++) cache[k] = new Integer(j++); } private IntegerCache() {} }

ValueOf方法

public static Integer valueOf(int i) { assert IntegerCache.high >= 127; if (i >= IntegerCache.low && i<= IntegerCache.high) return IntegerCache.cache[i + (-IntegerCache.low)]; return new Integer(i); }

上述方法中的assert关键是断言，需要开启-ea开关就可以生效，具体作用不详，猜测是判断缓存方面的。

关于包装类缓存的例子：

Integer i8=128; Integer i9=128; System.out.println(i8==i9); Integer i10=-128; Integer i11=-128; System.out.println(i10==i11); Integer i12=new Integer(1002); Integer i13=new Integer(1002); System.out.println(i12==i13);

三、 Java中定义可变参数的方法

在含有可变参数的方法中，可变参数应放在参数列表的末尾。且只可使用一组可变参数。如果设置多种数据类型的数据为可变参数，请使用集合。可变参数实际上是一个数组。

例子：

@Test public voidtestVariable(){ List list=new ArrayList(); List list1=new ArrayList(); List list2=new ArrayList(); List list3=new ArrayList(); list1.add("1"); list1.add("2"); list2.add("1"); list2.add("2"); list3.add("hha"); list.add(list1); list.add(list2); list.add(list3); haha("hah",list,list1,list2,list3); } public voidhaha(String hah,List...is){ System.out.println(hah); for(Object i:is){ System.out.println(i); } }

四、 Arrays

java.util 类 Arrays

java.lang.Object

java.util.Arrays

public class Arrays

extends Object

此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。

此类中所含方法的文档都包括对实现的简短描述。应该将这些描述视为实现注意事项，而不应将它们视为规范的一部分。实现者应该可以随意替代其他算法，只要遵循规范本身即可。（例如，sort(Object[]) 使用的算法不必是一个合并排序算法，但它必须是稳定的。）

此类是 JavaCollections Framework 的成员。

1. 使用aList方法，将数组转换为List集合

static

asList(T... a) 返回一个受指定数组支持的固定大小的列表。

方法中的参数需要为引用数据类型；如果传入了基本数据类型的数组，那么，将会把整个数组作为一个引用数据类型返回。转换后的集合不能做修改操作，因为不支持。

例子：

@Test public voidtestaList(){ String[] str=new String[]{"1","22","hh","xx"}; int[] in=newint[]{1,2,3,4,5}; List list1=Arrays.asList(str); List list2=Arrays.asList(in); System.out.println(list1); System.out.println(list2); list2.add(7);//不支持的操作 System.out.println(list2); }

2. Copy数组

static int[]

copyOf(int[] original, int newLength) 复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

static int[]

copyOfRange(int[] original, int from, int to) 将指定数组的指定范围复制到一个新数组。

CopyOfRange方法说明：

将指定数组的指定范围复制到一个新数组。该范围的初始索引 (from) 必须位于 0 和 original.length（包括）之间。original[from] 处的值放入副本的初始元素中（除非 from == original.length 或 from == to）。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to)（必须大于等于 from）可以大于 original.length，在这种情况下，0 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from。

例子：

@Test public voidtestCopyArray(){ int[] in=newint[]{1,2,4,5,6}; int[] in2=Arrays.copyOf(in, 2); for(int i:in2){ System.out.println(i); } int[] in3=Arrays.copyOfRange(in, 1, 7);//取前不取后 for(int i:in3){ System.out.println(i); } }

五、 Collections

java.util 类 Collections

java.lang.Object

java.util.Collections

public class Collections

extends Object

此类完全由在 collection 上进行操作或返回collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定collection 支持的新 collection，以及少数其他内容。

如果为此类的方法所提供的 collection 或类对象为null，则这些方法都将抛出 NullPointerException。

此类中所含多态算法的文档通常包括对实现的简短描述。应该将这类描述视为实现注意事项，而不是规范的一部分。实现者应该可以随意使用其他算法替代，只要遵循规范本身即可。（例如，sort 使用的算法不一定是合并排序算法，但它必须是稳定的。）

此类中包含的“破坏性”算法，即可修改其所操作的 collection 的算法，该算法被指定在 collection 不支持适当的可变基元（比如 set 方法）时抛出 UnsupportedOperationException。如果调用不会对 collection 产生任何影响，那么这些算法可能（但不要求）抛出此异常。例如，在已经排序的、不可修改列表上调用 sort 方法可能会（也可能不会）抛出UnsupportedOperationException。

1. Field

static List

EMPTY_LIST 空的列表（不可变的）。

static Map

EMPTY_MAP 空的映射（不可变的）。

static Set

EMPTY_SET 空的 set（不可变的）。

用法，比如需要返回空的集合或者映射时。使用这个字段返回的集合不可以做修改操作。

public voidtest01(){ List list=Collections.EMPTY_LIST; System.out.println(list); }

2. addAll

static

<T> boolean

addAll(Collection<? super T> c, T... elements) 将所有指定元素添加到指定 collection 中。

将所有指定元素添加到指定 collection 中。可以分别指定要添加的元素，或者将它们指定为一个数组。此便捷方法的行为与c.addAll(Arrays.asList(elements)) 的行为是相同的，但在大多数实现下，此方法运行起来可能要快得多。

在分别指定元素时，此方法提供了将少数元素添加到现有 collection 中的一个便捷方式：

Collections.addAll(flavors, "Peaches 'n Plutonium","Rocky Racoon");

例子：

public voidtest02(){ List list=new ArrayList(); int[] in=newint[]{1,2,4,5}; String[] str={"1","2","5","7"}; Integer[] inte={1,2,4,5}; Collections.addAll(list, in);//同样的如果使用基本类型为参数，将返回这个基本类型表示的数组，而不是数组中的元素 System.out.println(list); Collections.addAll(list, inte); System.out.println(list); Collections.addAll(list, "1","2","3"); System.out.println(list); }

3. binarySearch

static

<T> int

binarySearch(List<? extends Comparable<? super T>> list, T key) 使用二分搜索法搜索指定列表，以获得指定对象。

使用二分查找的要求：a.集合中的元素是自然排序的有序的，b.如果集合中存放的是自定义类型的对象，这个自定义的类型需要具备比较功能（即实现了Comparable接口，或者需要传递一个比较器Comparator）。

例子：

二分查找基本数据类型

public voidtest03(){ List list=new ArrayList(); Collections.addAll(list,1,2,4,5,66,78,909,1111); int binary=Collections.binarySearch(list, 67); System.out.println(binary); }

二分查找定义类型

自定义类型实现comparable接口

public class Person implements Comparable<Person>{ int age=0; public Person(intage){ super(); this.age=age; } public intcompareTo(Person o){ return this.age-o.age; } }

比较

public voidtest04(){ List list=new ArrayList(); Collections.addAll(list, new Person(5),new Person(8),new Person(9),new Person(19)); System.out.println(list); int binary=Collections.binarySearch(list, newPerson(9)); System.out.println(binary); }

4. fill

static

<T> void

fill(List<? super T> list, T obj) 使用指定元素替换指定列表中的所有元素。

例子：

public voidtest05(){ List list=new ArrayList(); Collections.addAll(list,1,2,4,5,66,78,909,1111); Collections.fill(list,"hh"); System.out.println(list); }

5. replaceAll

static

<T> boolean

replaceAll(List<T> list, T oldVal, T newVal) 使用另一个值替换列表中出现的所有某一指定值。

例子：

public voidtest06(){ List list=new ArrayList(); Collections.addAll(list,1,2,4,5,66,78,909,1111); Collections.replaceAll(list,2,"hh"); System.out.println(list); }

6. Max||Min

static

<T extends Object & Comparable<? super T>> T

max(Collection<? extends T> coll) 根据元素的自然顺序，返回给定 collection 的最大元素。

static

<T> T

max(Collection<? extends T> coll, Comparator<? super T> comp) 根据指定比较器产生的顺序，返回给定 collection 的最大元素。

static

<T extends Object & Comparable<? super T>> T

min(Collection<? extends T> coll) 根据元素的自然顺序返回给定 collection 的最小元素。

static

<T> T

min(Collection<? extends T> coll, Comparator<? super T> comp)

使用max或者min的要求，基本数据类型要自然排序，自定义类型需要比较器

例子：

@Test public voidtest07(){ List list=new ArrayList(); Collections.addAll(list,1,2,4,5,66,78,909,1111); System.out.println(Collections.max(list)); } //类的比较器同上 @Test public voidtest08(){ List list=new ArrayList(); Collections.addAll(list, new Person(5),new Person(8),new Person(9),new Person(19)); System.out.println(Collections.max(list)); }

7. shuffle

static void

shuffle(List<?> list, Random rnd) 使用指定的随机源对指定列表进行置换。

例子：

public voidtest09(){ List list=new ArrayList(); Collections.addAll(list,1,2,4,5,66,78,909,1111); System.out.println(list); Collections.shuffle(list); System.out.println(list); }

8. sort

static

<T extends Comparable<? super T>> void

sort(List<T> list) 根据元素的自然顺序对指定列表按升序进行排序。

static

<T> void

sort(List<T> list, Comparator<? super T> c) 根据指定比较器产生的顺序对指定列表进行排序。

使用sort的要求，自定义类型需要比较器

例子：

@Test public voidtest10(){ List list=new ArrayList(); Collections.addAll(list, 1,7,4,5,2,66,12); Collections.sort(list); System.out.println(list); } 比较器同上 @Test public voidtest11(){ List list=new ArrayList(); Collections.addAll(list, new Person(6),new Person(2),new Person(9),new Person(1)); System.out.println(list); Collections.sort(list); System.out.println(list); }

六、 String

java.lang 类 String

java.lang.Object

java.lang.String

所有已实现的接口：

Serializable, CharSequence, Comparable<String>

public final class String

extends Object

implements Serializable, Comparable<String>, CharSequence

String 类代表字符串。Java 程序中的所有字符串字面值（如"abc" ）都作为此类的实例实现。

字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的，所以可以共享。例如：

String str ="abc";

等效于：

char data[] ={'a', 'b', 'c'};

String str =new String(data);

下面给出了一些如何使用字符串的更多示例：

System.out.println("abc");

String cde ="cde";

System.out.println("abc" + cde);

String c ="abc".substring(2,3);

String d =cde.substring(1, 2);

String 类包括的方法可用于检查序列的单个字符、比较字符串、搜索字符串、提取子字符串、创建字符串副本并将所有字符全部转换为大写或小写。大小写映射基于Character 类指定的 Unicode 标准版。

Java 语言提供对字符串串联符号（"+"）以及将其他对象转换为字符串的特殊支持。字符串串联是通过StringBuilder（或 StringBuffer）类及其append 方法实现的。字符串转换是通过 toString 方法实现的，该方法由Object 类定义，并可被 Java 中的所有类继承。有关字符串串联和转换的更多信息，请参阅 Gosling、Joy 和Steele 合著的 The Java Language Specification。

除非另行说明，否则将 null 参数传递给此类中的构造方法或方法将抛出 NullPointerException。

String 表示一个 UTF-16 格式的字符串，其中的增补字符由代理项对表示（有关详细信息，请参阅 Character 类中的 Unicode字符表示形式）。索引值是指 char 代码单元，因此增补字符在 String 中占用两个位置。

String 类提供处理 Unicode代码点（即字符）和 Unicode 代码单元（即 char 值）的方法。

1. 关于创建String时产生对象的数量

这个问题涉及到jvm的内存结构。Jvm的内存结构主要有三大块：堆内存、方法区和栈。

Heap(java堆)，是java虚拟机管理的内存中的最大的一块，被所有线程共享的一块内存区，在虚拟机启动时创建。堆专门用来存放对象实例，即new出来的东西。Java堆也是垃圾收集器管理的主要区域，GC堆，垃圾收集堆，指的就是这个堆。如果堆中没有足够的内存分配给对象实例，而且堆也无法扩展时，则抛出OutOfMemoryError(内存溢出错误)。

Method Area（方法区），同样被线程共享的内存区域，用于存储被虚拟机加载的类信息、常量、静态变量等数据。为了与堆区别，方法区又叫做Non-Heap（非堆）。同样，当方法区无法满足程序对内存的需求时，将抛出OutOfMemoryError。

JVM Stacks（JVM栈），java虚拟机栈被线程私有，生命周期与线程等同。区别与堆中数据的垃圾回收机制。Jvm中，栈的存取速度仅次于Register（CPU寄存器），高于Heap。Java程序运行的编译期，主要是编译类文件，编译期间，会确定各种基本类型和对象引用等信息。在类加载期，当使用某个类的时候，jvm才会加载类，加载的位置即内存，加载动作只执行一次。在类执行期，jvm执行.class文件基于栈。类执行的动作主要就是方法，每个方法被执行的时候会创建一个栈帧。这个栈帧用于存放局部变量表、操作栈、方法出口等。其中，局部变量表存放了编译期已经确定的基本数据类型和对象的引用等。堆中存放的是对象本身，而对于对象的使用，一般在方法中进行，而方法中的需要的数据存放在栈中，调用对象，是通过栈帧中的对象引用。可见，在存取数据上，栈与堆的区别。关于栈的异常，线程请求的栈深度大于虚拟机所允许的深度，栈深度也被当做是栈的高度。每个方法被调用到执行完成，都是一个栈帧在虚拟机的栈内存中压栈和出栈的过程。如果调用的方法很多，造成很多栈帧的压栈，如果超出了这个栈的容量，就产生StackOverflowError异常，栈溢出异常。如果虚拟机可以扩展，当扩展仍无法满足栈的内存需要，就抛出OutOfMemoryError。

需要明确，string字符串是常量的存在，上述，常量是存放在方法区，一般称方法区中这个存放常量的地方为常量池。所以，当直接用String类赋值时，创建的是一个常量，在常量池中创建一个String对象，而且，这个String对象可以被不同的String常量名共享。常量池中的数据在编译期被确定。

String a=”aaa”;创建的是一个对象。

String a=new String(“aaa”);涉及到被创建的两个对象。

String a=newString(“aaa”);String b=new String(“aaa”);涉及到被创建的3个对象。

2. String类常用的方法

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) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。

int

lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。

int

lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。

int

lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。

int

lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

String

substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串。

String

substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。

例子：

public voidtest12(){ String ss="会话看看浏览会话上述得到存储"; System.out.println(ss.length()); System.out.println(ss.charAt(2)); System.out.println(ss.indexOf('g')); System.out.println(ss.indexOf('浏')); System.out.println(ss.lastIndexOf('到')); System.out.println(ss.substring(3)); }

2) 判断相关

是否为空，是否相等，是否包含，是否以指定字符串开头，是否以指定字符串结尾

boolean

isEmpty() 当且仅当 length() 为 0 时返回 true。

boolean

equals(Object anObject) 将此字符串与指定的对象比较。

boolean

contains(CharSequence s) 当且仅当此字符串包含指定的 char 值序列时，返回 true。

boolean

endsWith(String suffix) 测试此字符串是否以指定的后缀结束。

boolean

startsWith(String prefix) 测试此字符串是否以指定的前缀开始。

boolean

startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。

例子：

public voidtest13(){ String ss="会话看看浏览会话上述得到存储"; String ss2="看看"; System.out.println(ss.isEmpty()); System.out.println(ss.equals(ss2)); System.out.println(ss.contains(ss2)); System.out.println(ss.endsWith("会话")); System.out.println(ss.startsWith("看看")); }

3) 转换相关

转为字符数组，转为字节数组，字母大小写转换，去除字符串前后的空

char[]

toCharArray() 将此字符串转换为一个新的字符数组。

byte[]

getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

byte[]

getBytes(Charset charset) 使用给定的 charset 将此 String 编码到 byte 序列，并将结果存储到新的 byte 数组。

String

toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

String

toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

String

trim() 返回字符串的副本，忽略前导空白和尾部空白。

例子：

public voidtest14(){ String ss=" 会话看ss看浏览SSS会话上述得到存储 "; char[] css=ss.toCharArray(); for(char c:css){ System.out.println(c); } byte[] bss=ss.getBytes(); for(byte b:bss){ System.out.println(b); } System.out.println(ss.toUpperCase()); System.out.println(ss.toLowerCase()); System.out.println(ss.trim()); }

4) 拼接、替换和分割

String

concat(String str) 将指定字符串连接到此字符串的结尾。

String

replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

String

replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

String

replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

String[]

split(String regex) 根据给定正则表达式的匹配拆分此字符串。

String[]

split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串。

例子：

public voidtest15(){ String a="hh会话"; String b=a+"kkk浏览"; String c=b.concat(a); System.out.println(a); System.out.println(b); System.out.println(c); a=a.replace("hh", "kk"); System.out.println(a); String d="h会话hhh啦啦啦啦hh来来来hh看看"; String e[]=d.split("h+"); for(String f:e){ System.out.println(f); } }

5) 正则表达式相关

可以使用正则表达式做一些正则判断。

boolean

matches(String regex) 告知此字符串是否匹配给定的正则表达式。

例子：

public voidtest16(){ String ss="65758899"; String pattern="^[1-9][0-9]{6,7}"; if(ss.matches(pattern)){ System.out.println("是电话号"); }else{ System.out.println("不是电话号"); } }

七、 StringBuffer

java.lang 类 StringBuffer

java.lang.Object

java.lang.StringBuffer

所有已实现的接口：

Serializable, Appendable, CharSequence

public final class StringBuffer

extends Object

implements Serializable, CharSequence

线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步，因此任意特定实例上的所有操作就好像是以串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。

StringBuffer 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串，然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端；而 insert 方法则在指定的点添加字符。

例如，如果 z 引用一个当前内容为 "start"的字符串缓冲区对象，则此方法调用 z.append("le") 会使字符串缓冲区包含 "startle"，而 z.insert(4,"le") 将更改字符串缓冲区，使之包含 "starlet"。

通常，如果 sb 引用 StringBuilder 的一个实例，则sb.append(x) 和 sb.insert(sb.length(), x)具有相同的效果。

当发生与源序列有关的操作（如源序列中的追加或插入操作）时，该类只在执行此操作的字符串缓冲区上而不是在源上实现同步。

每个字符串缓冲区都有一定的容量。只要字符串缓冲区所包含的字符序列的长度没有超出此容量，就无需分配新的内部缓冲区数组。如果内部缓冲区溢出，则此容量自动增大。从 JDK 5 开始，为该类补充了一个单个线程使用的等价类，即 StringBuilder。与该类相比，通常应该优先使用 StringBuilder类，因为它支持所有相同的操作，但由于它不执行同步，所以速度更快。

主要方法：拼接，插入，修改，删除，反转

StringBuffer

append(String str) 将指定的字符串追加到此字符序列。

StringBuffer

insert(int offset, String str) 将字符串插入此字符序列中。

void

setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。

StringBuffer

deleteCharAt(int index) 移除此序列指定位置的 char。

StringBuffer

delete(int start, int end) 移除此序列的子字符串中的字符。

StringBuffer

reverse() 将此字符序列用其反转形式取代。

例子：

public voidtest17(){ StringBuffer sb=new StringBuffer("哈哈哈哈或"); sb=sb.append("hhhh"); System.out.println(sb); sb.append(false); System.out.println(sb); sb=sb.insert(2, "看看"); System.out.println(sb); sb.setCharAt(1, '是'); System.out.println(sb); sb.deleteCharAt(3); System.out.println(sb); sb.reverse(); System.out.println(sb); }

关于StringBuffer的容量

int

capacity() 返回当前容量。

每个新建的StringBuffer的容量为其长度加上16。当后续append时，如果append的内容的长度小于或等于16，则容量保持不变；如果append的内容的长度大于16但是(append的长度+原容量)<=(原容量*2+2)，则容量扩展为原容量*2+2，如果(append的长度+原容量)>(原容量*2+2)，则容量扩展为(原容量-16)【原容量-16，也就是原来的StringBuffer的长度】+append内容的长度，或者表示为：原StringBuffer的长度+append内容的长度。

例子：

public voidtest18(){ StringBuffer sb=new StringBuffer("1144"); System.out.println(sb.length()); System.out.println(sb.capacity()); sb.append("111111111111111444"); System.out.println(sb.length()); System.out.println(sb.capacity()); }

八、 Date

java.util 类 Date

java.lang.Object

java.util.Date

所有已实现的接口：

Serializable, Cloneable, Comparable<Date>

直接已知子类：

Date, Time, Timestamp

public class Date

extends Object

implements Serializable, Cloneable, Comparable<Date>

类 Date 表示特定的瞬间，精确到毫秒。

在 JDK 1.1 之前，类 Date 有两个其他的函数。它允许把日期解释为年、月、日、小时、分钟和秒值。它也允许格式化和解析日期字符串。不过，这些函数的 API 不易于实现国际化。从 JDK 1.1 开始，应该使用 Calendar 类实现日期和时间字段之间转换，使用 DateFormat 类来格式化和解析日期字符串。Date 中的相应方法已废弃。

尽管 Date 类打算反映协调世界时 (UTC)，但无法做到如此准确，这取决于 Java 虚拟机的主机环境。当前几乎所有操作系统都假定 1 天 = 24 × 60 × 60 = 86400 秒。但对于 UTC，大约每一两年出现一次额外的一秒，称为“闰秒”。闰秒始终作为当天的最后一秒增加，并且始终在 12 月 31 日或 6 月 30 日增加。例如，1995 年的最后一分钟是 61 秒，因为增加了闰秒。大多数计算机时钟不是特别的准确，因此不能反映闰秒的差别。

一些计算机标准是按照格林威治标准时 (GMT) 定义的，格林威治标准时和世界时 (UT) 是相等的。GMT 是标准的“民间”名称；UT 是相同标准的“科学”名称。UTC 和 UT 的区别是：UTC 是基于原子时钟的，UT 是基于天体观察的，两者在实际应用中难分轩轾。因为地球的旋转不是均匀的（它以复杂的方式减速和加速），所以 UT 始终不是均匀地流过。闰秒是根据需要引入 UTC 的，以便把 UTC 保持在 UT1 的 0.9 秒之内，UT1 是应用了某些更正的 UT 版本。还有其他的时间和日期系统；例如，基于卫星的全球定位系统 (GPS) 使用的时间刻度与 UTC 同步，但没有针对闰秒进行调整。有关更多信息的一个有趣来源是美国海军天文台，特别是 Directorate of Time 的网址： http://tycho.usno.navy.mil

还有它们对 "Systems of Time" 的定义，网址为： http://tycho.usno.navy.mil/systime.html

在类 Date 所有可以接受或返回年、月、日期、小时、分钟和秒值的方法中，将使用下面的表示形式：

年份 y 由整数 y - 1900 表示。

月份由从 0 至 11 的整数表示；0 是一月、1 是二月等等；因此 11 是十二月。

日期（一月中的某天）按通常方式由整数 1 至 31 表示。

小时由从 0 至 23 的整数表示。因此，从午夜到 1 a.m. 的时间是 0 点，从中午到 1 p.m. 的时间是 12 点。

分钟按通常方式由 0 至 59 的整数表示。

秒由 0 至 61 的整数表示；值 60 和 61 只对闰秒发生，尽管那样，也只用在实际正确跟踪闰秒的 Java 实现中。于按当前引入闰秒的方式，两个闰秒在同一分钟内发生是极不可能的，但此规范遵循 ISO C 的日期和时间约定。

在所有情形中，针对这些目的赋予方法的参数不需要在指定的范围内；例如，可以把日期指定为 1 月 32 日，并把它解释为 2 月 1 日的相同含义。

1. 常用方法

boolean

after(Date when) 测试此日期是否在指定日期之后。

boolean

before(Date when) 测试此日期是否在指定日期之前。

int

compareTo(Date anotherDate) 比较两个日期的顺序。

boolean

equals(Object obj) 比较两个日期的相等性。

String

toString() 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

long

getTime() 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

void

setTime(long time) 设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。

例子：

public voidtest1(){ Date d1=new Date(); System.out.println(d1); Date d2=new Date(20000000000000l); System.out.println(d2); System.out.println(d1.after(d2)); System.out.println(d1.before(d2)); System.out.println(d1.equals(d2)); System.out.println(d1.compareTo(d2)); System.out.println(d1.getTime()); d1.setTime(1000000000l); System.out.println(d1); System.out.println(d1.toString()); }

2. 日期的格式化

使用SimpleDateFormat类

java.text 类 SimpleDateFormat

java.lang.Object

java.text.Format

java.text.DateFormat

java.text.SimpleDateFormat

所有已实现的接口： Serializable, Cloneable

public class SimpleDateFormat

extends DateFormat

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

SimpleDateFormat 使得可以选择任何用户定义的日期-时间格式的模式。但是，仍然建议通过 DateFormat 中的 getTimeInstance、getDateInstance 或 getDateTimeInstance 来创建日期-时间格式器。每一个这样的类方法都能够返回一个以默认格式模式初始化的日期/时间格式器。可以根据需要使用 applyPattern 方法来修改格式模式。有关使用这些方法的更多信息，请参阅DateFormat。

Constructor

SimpleDateFormat(String pattern) 用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。

Method

StringBuffer

format(Date date, StringBuffer toAppendTo, FieldPosition pos) 将给定的 Date 格式化为日期/时间字符串，并将结果添加到给定的 StringBuffer。

void

applyPattern(String pattern) 将给定模式字符串应用于此日期格式。

Date

parse(String text, ParsePosition pos) 解析字符串的文本，生成 Date。

日期和时间模式：

日期和时间格式由日期和时间模式字符串指定。在日期和时间模式字符串中，未加引号的字母 'A' 到 'Z' 和 'a' 到'z' 被解释为模式字母，用来表示日期或时间字符串元素。文本可以使用单引号 (') 引起来，以免进行解释。"''" 表示单引号。所有其他字符均不解释；只是在格式化时将它们简单复制到输出字符串，或者在解析时与输入字符串进行匹配。

字母

日期或时间元素

表示

示例

Era 标志符

Text

年

Year

1996; 96

年中的月份

Month

July; Jul; 07

年中的周数

Number

月份中的周数

Number

年中的天数

Number

189

月份中的天数

Number

月份中的星期

Number

星期中的天数

Text

Tuesday; Tue

Am/pm 标记

Text

一天中的小时数（0-23）

Number

一天中的小时数（1-24）

Number

am/pm 中的小时数（0-11）

Number

am/pm 中的小时数（1-12）

Number

小时中的分钟数

Number

分钟中的秒数

Number

毫秒数

Number

978

时区

General time zone

Pacific Standard Time; PST; GMT-08:00

时区

RFC 822 time zone

-0800

例子：

public voidtestToString(){ SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-ddHH:mm:ss"); Date d=new Date(); System.out.println(d); String sd=sdf.format(d); System.out.println(sd); sdf.applyPattern("yyyy.MM.dd HH.mm.ss"); String sd2=sdf.format(d); System.out.println(sd2); String sd3="1999:02:1111:23:33"; SimpleDateFormat sdf2=new SimpleDateFormat("yyyy:MM:ddHH:mm:ss"); Date d2; try { d2 = sdf2.parse(sd3); System.out.println(d2); } catch (ParseException e) { e.printStackTrace(); } }

九、 Calendar

java.util 类 Calendar

java.lang.Object

java.util.Calendar

所有已实现的接口：

Serializable, Cloneable, Comparable<Calendar>

直接已知子类：

GregorianCalendar

public abstract class Calendar

extends Object

implements Serializable, Cloneable, Comparable<Calendar>

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的00:00:00.000，格里高利历）的偏移量。

该类还为实现包范围外的具体日历系统提供了其他字段和方法。这些字段和方法被定义为 protected。

Field

static int

DAY_OF_MONTH get 和 set 的字段数字，指示一个月中的某天。

static int

DAY_OF_WEEK get 和 set 的字段数字，指示一个星期中的某天。

static int

DAY_OF_WEEK_IN_MONTH get 和 set 的字段数字，指示当前月中的第几个星期。

static int

DAY_OF_YEAR get 和 set 的字段数字，指示当前年中的天数。

static int

HOUR_OF_DAY get 和 set 的字段数字，指示一天中的小时。

static int

WEEK_OF_MONTH get 和 set 的字段数字，指示当前月中的星期数。

static int

WEEK_OF_YEAR get 和 set 的字段数字，指示当前年中的星期数。

获取属性的方法

int

get(int field) 返回给定日历字段的值。

获取日历的方法

static Calendar

getInstance() 使用默认时区和语言环境获得一个日历。

例子：

public voidtestCalendar(){ Calendar c=Calendar.getInstance(); System.out.println(c.get(Calendar.YEAR)+"年"+ (c.get(Calendar.MONTH)+1)+"月"+ c.get(Calendar.DAY_OF_MONTH)+"日"+ c.get(Calendar.HOUR_OF_DAY)+"时"+ c.get(Calendar.MINUTE)+"分"+ c.get(Calendar.SECOND)+"秒" ); }

关于月份字段：在格里高利历和罗马儒略历中一年中的第一个月是JANUARY，它为 0；最后一个月取决于一年中的月份数。

常用方法

void

setTime(Date date) 使用给定的 Date 设置此 Calendar 的时间。

void

setTimeInMillis(long millis) 用给定的 long 值设置此 Calendar 的当前时间值。

void

set(int field, int value) 将给定的日历字段设置为给定值。

void

set(int year, int month, int date) 设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。

void

set(int year, int month, int date, int hourOfDay, int minute) 设置日历字段 YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY 和 MINUTE 的值。

void

set(int year, int month, int date, int hourOfDay, int minute, int second) 设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。

abstract void

add(int field, int amount) 根据日历的规则，为给定的日历字段添加或减去指定的时间量。

例子：

public staticvoidtestCalendar(Calendar c){ System.out.println(c.get(Calendar.YEAR)+"年"+ (c.get(Calendar.MONTH)+1)+"月"+ c.get(Calendar.DAY_OF_MONTH)+"日"+ c.get(Calendar.HOUR_OF_DAY)+"时"+ c.get(Calendar.MINUTE)+"分"+ c.get(Calendar.SECOND)+"秒" ); } public staticvoidmain(String[] args){ Calendar c=Calendar.getInstance(); c.setTimeInMillis(999999977777777l); testCalendar(c); c.set(1990, 12,22); testCalendar(c); c.add(Calendar.YEAR, 5); testCalendar(c); c.add(Calendar.HOUR, 5); testCalendar(c); }

转载请注明原文地址: https://www.6miu.com/read-46420.html

技术

最新回复(0)