工具类
1. 概述
提下更方便地使用一些固定的方法。
2. 特点
- 工具类的方法一般全是静态方法。
- 工具类的使用一般直接用类名调用方法。
- Java 5以及更新版本中，可以使用静态导入，这样可以免除类名的输入。
Collections类
1. 概述
Collections类是集合框架中的一个工具类，用于操作集合对象，它的方法全都是静态的，不需要创建对象，并未封装特有数据。
2. 方法
- 二分查找
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) - 获取最大值和最小值
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) - 全部替换，单独替换和交换
static <T> void fill(List<? super T> list, T obj)
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
static void swap(List<?> list, int i, int j) - 逆序排列（直接逆序或获取逆序比较器）
static void reverse(List<?> list)
static <T> Comparator<T> reverseOrder()
static <T> Comparator<T> reverseOrder(Comparator<T> cmp) - 随机排列
static void shuffle(List<?> list)
static void shuffle(List<?> list, Random rnd) - 排序
static <T extends Comparable<? super T>> void sort(List<T> list)
static <T> void sort(List<T> list, Comparator<? super T> c) - 获取线程安全的集合
static <T> Collection<T> synchronizedCollection(Collection<T> c)
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)
3. Collection类和Collections类的区别
- Collection是集合框架中的一个顶层接口，提供了单列集合的最基本操作，并且其实现能够提供元素的存储等，所以使用时必须new出集合对象。
- Collections是集合框架的一个工具类，由静态方法构成，主要提供了对集合进行操作的一系列方法，所以使用时必须传入集合对象参数。
4. 示例
package tools;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import comparator.ComparatorByLength;
public class CollectionsDemo {
public static void main(String[] args) {
/*
* 1. 将非同步的集合转成同步的集合
* 2. 获取List集合最值。
* 3. 对List集合排序。
* 4. 对List集合进行元素插入，并保持有序。
* 5. 对List集合进行按字符串由长到短排序。
* 6. 保留List集合前2个以及后2个元素，将其他元素替换为"null"。
*/
List<String> l = new ArrayList<String>();
init(l );
// 1. 将非同步集合转换成同步集合。
List<String> list = Collections.synchronizedList(l );
// 2. 获取List集合最值。
String max = Collections. max(list); // "zzz"
String min = Collections. min(list); // "abcde"
// 3. 对List集合排序。
Collections.sort(list ); // [ abcde, it&java, java, me, nba, zoom, zzz ]
// 4. 对List集合进行元素插入，并保持有序。
String str = "niubility";
int index = Collections.binarySearch(list , str );
// 如果集合中无此元素，则返回-(insertion point) - 1
if (index < 0) {
index = -(index + 1);
}
list.add(index, str); // [abcde, it&java, java, me, nba, niubility , zoom, zzz]
// 5. 对List集合进行按字符串由长到短排序。
Collections.sort(list , Collections.reverseOrder (new ComparatorByLength()));
// [niubility, it&java, abcde, zoom, java, zzz , nba, me]
// 6. 保留List集合前2个以及后2个元素，将其他元素替换为"null"。
replaceFunc(list ); // [ niubility, it&java, null, null, null, null, nba, me]
}
private static void replaceFunc(List<String> list) {
List<String> l = new ArrayList<String>();
// 1. 先将中间需要替换的元素存入新集合，并在老集合中删除这些元素。
for (int i = 2; i < list.size() - 2; i++) {
l.add(list.get(i));
/*
* 由于remove会使得后面的元素替代到这个位置上
* 所以要让i--抵消掉下一轮的i++，也就是说重新判断该位置上的元素。
* 并且每趟循环必须重新计算list.size();
*/
list.remove(i--);
}
// 2. 将新集合中的元素全部替换。
Collections.fill(l , "null" );
// 3. 将新集合中的元素全部添加回老集合。
list.addAll(2, l);
}
public static void init(Collection<String> c) {
c.clear();
c.add("java");
c.add("abcde");
c.add("zzz");
c.add("it&java");
c.add("me");
c.add("nba");
c.add("zoom");
}
}
Arrays类
1. 概述
Arrays类是一个操作数组的工具类，全部由静态方法构成，不需要创建对象，并没有封装特定的数据。
2. 方法
- 将数组转换为集合
static <T> List<T> asList(T... a) - 二分查找（以byte为例）
static int binarySearch(byte[] a, byte key)
static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key)
static <T> int binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c)
static <T> int binarySearch(T[] a, T key, Comparator<? super T> c) - 填充数据（以byte为例）
static void fill(byte[] a, byte val)
static void fill(byte[] a, int fromIndex, int toIndex, byte val) - 数组复制（以byte为例）
static byte[] copyOf(byte[] original, int newLength)
static byte[] copyOfRange(byte[] original, int from, int to) - 排序（以byte为例）
static void sort(byte[] a)
static void sort(byte[] a, int fromIndex, int toIndex)
static <T> void sort(T[] a, Comparator<? super T> c)
static <T> void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) - 生成字符串（以byte为例）
static String toString(byte[] a)
3. 示例
package tools;
import java.util.Arrays;
public class ArraysDemo {
public static void main(String[] args) {
/*
* Arrays: 用于操作数组的工具类，由一系列静态方法构成。
* 1. 对数组排序。
* 2. 二分查找。
* 3. 数组复制。
* 4. 对两个数组进行元素的比较，判断两个数组是否相同。
* 5. 将数组转成字符串。
*/
int[] arr = {34, 21, 67, 99, 18};
// 1. 对数组排序。
Arrays.sort(arr ); // [18, 21, 34, 67, 99]
// 2. 二分查找。
int index1 = Arrays. binarySearch(arr, 55); // -4 (-(insertion point) - 1)
int index2 = Arrays. binarySearch(arr, 67); // 3
// 3. 数组复制
int[] arrCopy = Arrays.copyOfRange(arr , 1, 3); // [21, 34]，含头不含尾
// 4. 对两个数组进行元素的比较，判断两个数组是否相同。
boolean b = Arrays. equals(arr, arrCopy); // false
// 5. 将数组转换成字符串
String str = Arrays.toString(arr ); // [18, 21, 34, 67, 99]
System.out.println( str);
}
}
集合和数组的相互转换
1. 数组转集合
目的：使得可以使用集合中的方法对元素进行操作。
方法：List<T> Arrays.asList()(T... a)
特点
- 集合不可修改，因为数组转出的集合为常量集合，否则报UnsupportedOperationException异常。
- 如果数组中存储的是基本数据类型，那么转成集合，数组对象会作为集合中唯一的元素存在，所以需要注意。
如果数组中存储的是引用数据类型，那么转成集合，数组元素会作为集合元素存在。
2. 集合转数组
目的：限制对元素的增删操作。
方法：Collection对象：<T> T[] toArray(T[] a)
特点
- 如果参数的数组的长度小于集合的长度，会创建一个同类型的数组，长度为集合的长度。
如果参数的数组的长度大于集合的长度，就会使用这个数组，没有存储元素的位置为null。 - 参数数组的长度最好直接定义为和集合长度一致。
3. 示例
package collection.list;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
public class List2Array {
public static void main(String[] args) {
/*
* 数组转集合
* 目的：使得可以使用集合中的方法对元素进行操作。
* 但是不可修改集合，因为得到的集合是常量集合，否则UnsupportedOperationException
* 如果数组中存储的是基本数据类型，那么转成集合，数组对象会作为集合中唯一的元素存在。
* 如果数组中存储的是引用数据类型，那么转成集合，数组元素会作为集合元素存在。
*/
int[] arr = {22, 85, 45, 65, 19, 4, 96};
String[] strs = {"a", "b", "c" };
// 数组转集合
List<int[]> listArr = Arrays.asList( arr); // [[I@15db9742]
List<String> listStr = Arrays. asList(strs); // [a, b, c]
/*
* 集合转数组
* 目的：限制对元素的增删操作。
* 如果传递的数组的长度小于集合的长度，会创建一个同类型的数组，长度为集合的长度。
* 如果传递的数组的长度大于集合的长度，就会使用这个数组，没有存储元素的位置为null。
* 长度最好直接定义为和集合长度一致。
*/
Collection<String> c = new ArrayList<String>();
init(c );
// 集合转数组
String[] arrStrs = c.toArray( new String[ c.size()]);
// [java, abcde, zzz, itheima , me]
// 也可以用无参数的toArray方法，但是该方法返回Object类型数组，需要向下转型才可以使用。
}
public static void init(Collection<String> c) {
c.clear();
c.add("java");
c.add("abcde");
c.add("zzz");
c.add("itheima");
c.add("me");
}
}
Math类
1. 概述
Math数学运算。方法都是静态的，并且包括自然对数和圆周率常量。
2. 常用方法
static double abs(double a) // 绝对值
static double ceil(double a) // 向上取整
static double floor(double a) // 向下取整
static int round(float a) // 四舍五入
static long round(double a)
static double cbrt(double a) // 开立方
static double sqrt(double a) // 开方
static double exp(double a) // 自然对数的次方
static double pow(double a, double b) // 次方
static double log(double a) // 自然对数
static double log10(double a) // 10为底的对数
static double max(double a, double b) // 最大值
static double min(double a, double b) // 最小值
static double random() // 0~1的随机数（不包括1）
3. 示例
package tools;
public class MathDemo {
public static void main(String[] args) {
/*
* Math数学运算。方法都是静态的。
*/
int i = Math.abs(-4); // 4
double d0 = Math. sqrt(16); // 4
double d1 = Math. cbrt(8); // 2
double d2 = Math. ceil(12.54); // 13.0
double d3 = Math. floor(12.54); // 12.0
long d4 = Math.round(12.54); // 13
double d5 = Math. pow(10.1, 3.1); // 1298.3633826837624
double dr = Math. random(); // 0~1的随机数
}
}
系统相关类
1. System类
概述
该类全部由静态成员构成，无构造方法，不可以创建实例。
静态域
- 标准输入流
static InputStream in - 标准输出流
static PrintStream out
常用方法
- 数组复制
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) - 获取系统时间（毫秒）
static long currentTimeMillis() - 获取当前时间（纳秒，常用作计算程序消耗时间）
static long nanoTime() - 结束虚拟机
static void exit(int status) - 垃圾回收
static void gc() - 获取系统属性集或者属性集中的数据
static Properties getProperties()
static String getProperty(String key)
static String getProperty(String key, String def) - 设置系统属性集
static void setProperties(Properties props)
static String setProperty(String key, String value) - 获取当前系统下的换行符
static String lineSeparator() - 设置默认的输入输出流
static void setIn(InputStream in)
static void setOut(PrintStream out)
示例
package tools;
import java.util.Properties;
public class SystemDemo {
public static void main(String[] args) {
// 1. 数组复制
byte[] src = {5, 3, 7, 1, 9};
byte[] dest = new byte[5];
System.arraycopy(src , 2, dest , 0, 3); // [7, 1, 9, 0, 0]
// 2. 获取系统时间（毫秒）
long timeMillis = System. currentTimeMillis(); // 1418684143024
// 3. 获取当前时间（纳秒，常用作计算程序消耗时间）
long timeNano = System. nanoTime(); // 53653295860546
// 4. 结束虚拟机
//System.exit(0);
// 5. 垃圾回收
System.gc();
// 6. 获取系统属性集或者属性集中的数据
Properties prop = System. getProperties();
String osName = System. getProperty("os.name"); // Windows 7
// 7. 设置系统属性集
String osOldName = System. setProperty("os.name", "Windows 18");
String osNewName = System. getProperty("os.name"); // Windows 18
// 8. 获取当前系统下的换行符
String ls = System.lineSeparator();
String str = "java" + ls + "happy";
// java
// happy
}
}
2. Runtime类
概述
- 该类无构造方法，不可以通过new方法创建实例。
- 每个JVM运行都会在底层生成一个Runtime实例。
- 由于该类有非静态方法，那么只能通过静态方法获取该类实例。
常用方法
- 获取当前JVM的Runtime实例。
static Runtime getRuntime() - 按命令执行程序。
Process exec(String command)
Process exec(String command, String[] envp)
Process exec(String command, String[] envp, File dir)
Process exec(String[] cmdarray)
Process exec(String[] cmdarray, String[] envp)
Process exec(String[] cmdarray, String[] envp, File dir) - 结束JVM。
void exit(int status) - 执行垃圾回收
void gc() - 获取JVM已获取的未使用内存
long freeMemory() - 获取JVM最大可获取的内存
long maxMemory() - 获取当前JVM已获取的总内存
long totalMemory()
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
