集合——工具类_map集合返回复用工具类-CSDN博客

本文链接：https://blog.csdn.net/a254830856/article/details/24661115

Collections类 ：

用于操作集合的工具类，它的出现给集合操作提供了更多的功能。这个类不需要创建对象，内部提供的都是静态方法。

Collections工具类中常用的静态方法：

boolean addAll(list,elements)将指定元素添加到指定的Collection集合中

int binarySearch(list,value) 使用二分搜索法（又叫做折半查找）查找指定集合，获取指定的对象。前提：有序集合

T max(list)/min(list)根据元素的自然顺序，返回给定集合中的最大/小元素

void reverse(list) 翻转给定列表中的元素

void shuffle(list) 使用默认随机源对指定列表进行置换。

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

void swap(list,i,j) 在指定列表的指定位置处交换元素。

Collection synchronizedCollection(Collection c) 通过此方法将不支持线程同步的Collection集合转换成支持线程同步的Collection集合

代码示例：

/**
Collections工具类方法示例
*/
import java.util.*;
class CollectionsDemo 
{
	public static void main(String[] args) 
	{
		ArrayList<String> al1 = new ArrayList<String>();
		ArrayList<String> al2 = new ArrayList<String>();
		al1.add("java01");
		al1.add("java02");
		al1.add("java03");
		al1.add("java04");
		al1.add("java05");
		//将指定元素存入指定的集合中
		Collections.addAll(al2,"java01","java02");
		sop(al1);
		sop(al2);
		//对集合进行折半查找（前提：有序集合）
		sop(Collections.binarySearch(al1,"java02"));
		//按照自然排序的规则，查找集合中的最大元素，返回其角标值
		sop(Collections.max(al1));
		将指定集合中的元素进行反转
		Collections.reverse(al1);
		sop(al1);
		//将指定集合中的元素进行随机排列
		Collections.shuffle(al1);
		sop(al1);
		//将集合中的元素按照自然排序的规则进行排序
		Collections.sort(al1);
		sop(al1);
		//将指定集合中指定角标的元素进行位置调换
		Collections.swap(al1,0,2);
		sop(al1);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

将非同步集合转成同步集合的方法：Collections中的 XXX synchronizedXXX(XXX);
List synchronizedList(list);
Map synchronizedMap(map);
原理：定义一个类，将集合所有的方法加同一把锁后返回。

Collection 和 Collections的区别：

Collections是个java.util下的类，是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化（将非同步的集合转换成同步的）等操作。

Collection是个java.util下的接口，它是各种集合结构的父接口，继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。

Arrays工具类 ：用于操作数组对象的工具类，里面都是静态方法。

将数组转换成集合
asList方法：将数组转换成list集合。

代码示例：

/**
将数组转换成集合
list asList()方法
*/
import java.util.*;
class AsListDemo 
{
	public static void main(String[] args) 
	{
		String[] arr = new String[]{"java01","java02","java03","java04","java05"};
		//此处返回值类型只能是List，不可以是他的子类集合
		List<String> al = Arrays.asList(arr);
		System.out.println(al);
	}
}

将数组转换成集合，有什么好处呢？
用aslist方法，将数组变成集合后，可以使用List集合中的方法来操作数组中的元素：isEmpty()、contains、indexOf、set；
注意（局限性）：数组是固定长度，转换后的集合长度也是固定的，不可以使用集合对象增加或者删除等改变数组长度的方法。

比如add、remove、clear。（进行以上操作后程序会报不支持操作异常UnsupportedOperationException）；

如果数组中存储的引用数据类型，直接作为集合的元素可以直接用集合方法操作。
如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。

代码示例：

/**
将数组转换成集合
list asList()方法
*/
import java.util.*;
class AsListDemo 
{
	public static void main(String[] args) 
	{
		String[] arr1 = new String[]{"java01","java02","java03","java04","java05"};
		//此处返回值类型只能是List，不可以是他的子类集合
		List<String> al = Arrays.asList(arr1);
		System.out.println(al);
		//将数组中的元素自动装箱
		Integer[] arr2 = new Integer[]{1,2,3,4,5};
		List<Integer> l = Arrays.asList(arr2);
		System.out.println(l);
	}
}

集合变数组：用的是Collection接口中的方法：toArray();

如果给toArray传递的指定类型的数据长度小于了集合的size，那么toArray方法，会自定再创建一个该类型的数据，长度为集合的size。

如果传递的指定的类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其他为存储元素的位置默认值null。

所以，在传递指定类型数组时，最好的方式就是指定的长度和size相等的数组。

代码示例：

/*
集合变数组。
Collection接口中的toArray方法。
*/
import java.util.*;
class  CollectionToArray
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		//设置小于长度的值
		String[] a = al.toArray(new String[1]);
		System.out.println(Arrays.toString(a));
		//设置大于长度的值
		String[] b = al.toArray(new String[6]);
		System.out.println(Arrays.toString(b));
		//最好的方法是建立一个刚好存储集合中元素的数组
		String[] arr = al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(arr));
	}
}

结果：

将集合变成数组后的好处

限定了对集合中的元素进行增删操作，只要获取这些元素即可。

JDK5.0新特性：

高级for循环：
格式：
for( 元素类型变量名 : Collection集合 & 数组 ) {
…
}

高级for循环的作用：对集合和数组进行遍历

并且只能获取集合或者数组中的元素，不能对集合或者数组中的元素进行操作

相比较之下，迭代器除了遍历，还可以进行remove操作

代码演示：

/**
高级for循环演示
*/
import java.util.*;

class  ForDemo
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		al.add("java05");
		//遍历集合
		for (String s : al )
		{
			System.out.println(s);
		}
		//遍历数组
		int[] arr = new int[]{1,2,3,4,5}; 
		for (int i : arr)
		{
			System.out.println(i);
		}
	}
}

高级for循环和传统for循环的区别：

高级for循环在使用时，必须要明确被遍历的目标。这个目标，可以是Collection集合或者数组，如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，就只能使用迭代器了；

如果遍历数组，还需要对数组元素进行操作，建议用传统for循环因为可以定义角标通过角标操作元素。

如果只为遍历获取，可以简化成高级for循环，它的出现为了简化书写。

相比之下，传统for循环的使用更加灵活，可以定义变量记录循环次数等操作。

注意：高级for循环不可以遍历map集合，但是可以将map集合转成set集合后再使用高级for语句。

代码示例：

/**
高级for循环遍历map集合中的元素
1，将map集合转换为set集合
2，高级for 循环遍历set集合
*/
import java.util.*;

class  ForMap
{
	public static void main(String[] args) 
	{
		HashMap<Integer,String> hm = new HashMap<Integer,String>();
		hm.put(1,"java01");
		hm.put(2,"java02");
		hm.put(3,"java03");
		hm.put(4,"java04");
		hm.put(5,"java05");
		//第一种取出方式
		//注意此处只能用Set集合接收，不可以用HashSet集合接收
		Set<Integer> hs = hm.keySet();
		for (Integer s : hs)
		{
			System.out.println(s+"::"+hm.get(s));
		}
		//第二种取出方式
		Set<Map.Entry<Integer,String>> s = hm.entrySet();
		for (Map.Entry me : s)
		{
			System.out.println(me.getKey()+"::"+me.getValue());
		}
	}
}

可变参数（...）：

虽然少定义了多个方法。但是每次都要定义一个数组。作为实际参数。

函数的参数上，当要操作的同一个类型元素个数不确定的时候，可是用这个方式，这个参数可以接受任意个数的同一类型的数据。

代码示例：

/**
可变参数演示
*/
class ElementDemo 
{
	public static void main(String[] args) 
	{
		sum(3,4);
		/*
		虚拟机在后台将同一类型的数据封装进了数组
		int[] b = {3,4};
		将数组中的元素作为参数进行传递
		*/
		 
	}
	public static void sum(int... b)
	{
		System.out.println(a+b);
	}
	
}

可变参数的原理：

JVM隐式的将同一类型的数据进行封装，并将数组中的元素作为实际参数进行传递。

静态导入：导入了类中的所有静态成员，简化静态成员的书写。

import static java.util.Collections.*; //导入了Collections类中的所有静态成员

代码示例：

/**
静态导入演示
*/
import static java.util.Arrays.*;

class  StaticImport
{
	public static void main(String[] args) 
	{
		int[] arr = {1,2,3,4,5}; 
		//静态导入后，静态方法不用写类名
		System.out.println(binarySearch(arr,1));
	}
}

注意：

当类名重名时，需要指定具体的包名；

当方法重名时，需要指定其所属的对象或者类，例如：toString()方法

java.lang.System

System:类中的方法和属性都是静态的。
out:标准输出，默认是控制台。
in：标准输入，默认是键盘。

Properties

因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。
那么可以通过map的方法取出该集合中的元素。
该集合中存储都是字符串。没有泛型定义。

System中的方法：
获取系统属性信息：static Properties getProperties();

获取指定属性信息 static String getProperty(String key)

自定义特有信息：static String setProperty(String key, String value)

示例代码：

import java.util.*;
class SystemDemo 
{
	public static void main(String[] args) 
	{

		Properties prop = System.getProperties();
		
		//自定义特有信息
		System.setProperty("mykey","myvalue");
		//获取指定属性信息。
		String value = System.getProperty("os.name");
		System.out.println("value="+value);	
		//动态加载属性信息
		String v = System.getProperty("haha");
		System.out.println("v="+v);		
		//获取所有属性信息。
		for(Object obj : prop.keySet())
		{
			String val = (String)prop.get(obj);

			System.out.println(obj+"::"+val);
		}
	}
}

java.lang.Runtime

该类并没有提供构造函数。

说明不可以new对象。那么会直接想到该类中的方法都是静态的。

发现该类中还有非静态方法。

说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。

由这个特点可以看出该类使用了单例设计模式完成。

Runtime 方法

static Runtime getRuntime() ：返回与当前 Java 应用程序相关的运行时对象。

代码示例：

class  RuntimeDemo
{
	public static void main(String[] args) throws Exception
	{
		Runtime r = Runtime.getRuntime();
		Process p = r.exec("notepad.exe  SystemDemo.java");	
		//Thread.sleep(4000);
		//结束进程
		//p.destroy();
	}
}

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

时间的格式

年：y-->year

月：M-->month（m和时间的首字母重复了，所以是大写的）

日：d-->day

时：h-->hour

分：m-->minute

秒：s-->second

代码示例：

import java.util.*;
import java.text.*;
class DateDemo 
{
	public static void main(String[] args) 
	{
		Date d = new Date();
		System.out.println(d);

		//将模式封装到SimpleDateformat对象中。
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");
		//调用format方法让模式格式化指定Date对象。
		String time = sdf.format(d);
		System.out.println("time="+time);
		//获取某一时刻的时间
		long l = System.currentTimeMillis();
		Date d1 = new Date(l);
		System.out.println("d1:"+d1);
	}
}

java.util.Calendar

Calendar:

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法。

Calendar常用的方法：

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

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

注意：

计算机计算月份是从0开始的；在获取的月份的时候要加一

星期是从星期日开始的。获取星期的时候要减一

可以使用查表法，来减少这些麻烦。

代码示例：

import java.util.*;
class  CalendarDemo2
{
	public static void main(String[] args) 
	{

		Calendar c = Calendar.getInstance();

		c.set(2012,2,23);

		c.add(Calendar.DAY_OF_MONTH,-18);
		
		printCalendar(c);
	}

	public static void printCalendar(Calendar c)
	{
		String[] mons = {"一月","二月","三月","四月"
					,"五月","六月","七月","八月"
					,"九月","十月","十一月","十二月"};


		String[] weeks = {
				"","星期日","星期一","星期二","星期三","星期四","星期五","星期六",
				};		
		int index = c.get(Calendar.MONTH);

		int index1 = c.get(Calendar.DAY_OF_WEEK);

		sop(c.get(Calendar.YEAR)+"年");
		sop(mons[index]);
		sop(c.get(Calendar.DAY_OF_MONTH)+"日");
		sop(weeks[index1]);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

java.lang.Math

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
常用方法：

static max(a,b)

static min(a,b)

代码示例：

import java.util.*;

class  MathDemo
{
	public static void main(String[] args) 
	{
		saveTwo(12.3456,3,true);
	}

	public static void saveTwo(double d,int scale,boolean isRound)
	{
		
		double base = Math.pow(10,scale);
		double num = isRound?Math.round(d*base)/base:((int)(d*base))/base;
		sop("num="+num);
	}

	public static void show()
	{
		double d = Math.ceil(16.34);//ceil返回大于指定数据的最小整数。
		double d1 = Math.floor(12.34);//floor返回小于指定数据的最大整数。

		long l = Math.round(12.54);//四舍五入
		sop("d="+d);
		sop("d1="+d1);
		sop("l="+l);

		double d2 = Math.pow(2,3);
		sop("d2="+d2);
	}
	public static void sop(Object obj)
	{	
		System.out.println(obj);
	}
}