工具类
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) - 1if (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()
897
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
