黑马程序员--常见的API其他类

------- android培训 、 java培训 、期待与您交流！ ----------

1.Random类

    Random 用于产生随机数的类

    构造方法:

      Random()默认以系统时间作为随机数生成器的种子

      Random(long seed):以固定的seed参数作为随机数生成器的种子

    功能方法:

      public int nextInt()  int范围内的值

      public int nextInt(int n)  [0,n)之间的值

      随机输出一到一百之间的数值:Random r=new Random();r.nextInt(100)+1;

2.Math类

    Math类包含用于执行基本数学运算的方法，是数学操作常用的类。

    特点：沒有构造方法,都是静态的成员

    Math类要掌握的功能

      成员：

        PI   E

      方法：

        abs:绝对值

        ceil:大于等于参数的最小整数

        floor:小与等于参数的最大整数

        max:获取两个值中较大的值

        min:获取两个值中较小的值

        pow:获取x的y次方的值

        random:产生一个随机数,范围是[0.0,1.0)

        round:四舍五入

        sqrt:平方根

/*
 * 需求：猜数字小游戏。
 * 		首先程序生成一个1-100之间的随机数,键盘录入数据进行竞猜.
 * 
 * 思路：
 * 		1：程序产生一个随机数.1-100
 * 			(int)(Math.random()*100)+1
 * 		2：从键盘结束录入的数据
 * 		3：比较数据	
 * 			大了,提示大了
 * 			小了,提示小了
 * 			相等,恭喜你,中奖了
 * 		4：多次猜,用循环实现。
 * 		5：统计次数
 */
public class MathTest {
	public static void main(String[] args) {
		// 程序产生一个随机数
		int guessNumber = (int) (Math.random() * 100) + 1;
		// 获取键盘录入的数据
		Scanner sc = new Scanner(System.in);
		// 定义统计变量
		int count = 0;
		while (true) {
			count++;
			System.out.println("开始猜奖:");
			int number = sc.nextInt();
			// 判断是否猜对
			if (number > guessNumber) {
				System.out.println("你猜的数据" + number + "大了");
			} else if (number < guessNumber) {
				System.out.println("你猜的数据" + number + "小了");
			} else {
				System.out.println("恭喜你," + count + "次就中奖了");
				break;
			}
		}
	}
}

3.System类

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

    要掌握的功能：

       public static void exit(int status)：退出jvm，非0的状态码表示异常终止

       public static Properties getProperties()：获取系统的属性

       public static long currentTimeMillis()：获取当前时间的毫秒值，可以用来测试程序的运行时间

4.Runtime类

    Runtime：程序的运行时类的对象。

    特点：没有构造方法，但是通过单例的方式返回了该类的一个对象。

          public static Runtime getRuntime()

    方法：

          Process exec(String command) 在单独的进程中执行指定的字符串命令

          void gc() 运行垃圾回收器。

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

          void exit(int status) 通过启动虚拟机的关闭序列，终止当前正在运行的 Java 虚拟机

public class RuntimeDemo {
	public static void main(String[] args) {
		// 获取Runtime类的对象
		Runtime r = Runtime.getRuntime();

		try {
			 r.exec("notepad");
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

5.Date类

    Date类是日期类，用于日期数据的操作，参数为毫秒值.

    Daet类要掌握的功能:

       毫秒到日期的转换public void setTime(long time)

       日期到毫秒的转换public long getTime()

6.DateFormat

    DateFormat类是对日期进行格式化的类

    DateFormat本身是一个抽象类，所以必须使用的时候使用的是其子类SimpleDateFormatDateFormat

    DateFormat类要掌握的功能:

       从日期到字符串的转换  public final String format(Date date)

       从字符串到日期的转换  public Date parse(String source) throws ParseException

7.Calendar

    Calendar类是日历类，用于替代Date类的使用,它里面提供了很多功能来单独获取日历的某个数据.

    Calendar类是抽象类，但是提供方法用于获取子类对象

    Calendar类掌握的方法：

       public int get(int field) 根据给定的日历字段，获取对应的值

       public final void set(int year,int month,int date) 设置对应的时间

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

public class CalendarDemo {
	public static void main(String[] args) {
		// 创建日历对象
		Calendar c = Calendar.getInstance();
		System.out.println("c:" + getCalendar(c));
		//设置日期
		c.set(2008, 3, 5);
		System.out.println("c:" + getCalendar(c));
		c.add(Calendar.YEAR, 2);
		c.add(Calendar.HOUR, -4);
		System.out.println("c:" + getCalendar(c));

		// 我要获取任意一年的2月份的天数
		Scanner sc = new Scanner(System.in);
		int year = sc.nextInt();
		c.set(year, 2, 1); // 这里表示什么？表示任意一年的3月1日
		c.add(Calendar.DATE, -1);
		System.out.println("days:" + c.get(Calendar.DATE));
	}

	// 根据日历对象，返回字符串表示
	public static String getCalendar(Calendar c) {
		return c.get(Calendar.YEAR) + "年" + (c.get(Calendar.MONTH) + 1) + "月"
				+ c.get(Calendar.DATE) + "日" + " " + c.get(Calendar.HOUR) + ":"
				+ c.get(Calendar.MINUTE) + ":" + c.get(Calendar.SECOND);
	}
}

8.Arrays类

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

    a.将数组转换为List集合

    public static <T> List<T> asList(T... a)  返回一个受指定数组支持的固定大小的列表 ,即将数组转换为集合.

    注意：1.将数组变成集合，不可以使用集合的增删方法,因为数组的长度是固定.如果增删,会反生UnsupportedOperationException异常.

    2.如果数组中的元素都是对象,那么变成集合时，数组中的元素就直接转成集合中的元素.如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的一个元素存在.

    3.把数组变成list集合有什么好处？可以使用集合的思想和方法来操作数组中的元素.

class  ArraysDemo
{
	public static void main(String[] args) 
	{
		String[] arr = {"abc","cc","kkkk"};

		List<String> list = Arrays.asList(arr);
		sop("contains:"+list.contains("cc"));//利用集合方法判断是否包含"cc"
		list.add("qq");//数组转集合,无法使用增删方法,出现UnsupportedOperationException
		int[] nums1 = {2,4,5};
		Integer[] nums2 = {2,4,5};
		List<Integer> li1 = Arrays.asList(nums1);//将数组按一个元素看
		List<Integer> li2 = Arrays.asList(nums2);//数组中元素直接转换为集合中的元素
		sop(li1);
		sop(li2);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

    b.集合变数组：利用Collction中的toArray方法

    注意:1.指定类型的数组到底要定义多长呢？

       当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组,长度为集合的size.

       当指定类型的数组长度大于了集合的size，就不会新创建了数组,而是使用传递进来的数组.

    2.为什么要将集合变数组？

       为了限定对元素的操作,防止对集合元素进行增删.

class  CollectionToArray
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();

		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
		String[] arr = al.toArray(new String[al.size()]);
		System.out.println(Arrays.toString(arr));
	}
}

9.Collections类

    此类完全由在 collection 上进行操作或返回 collection 的静态方法组成.

    问题:Collections和Collection有什么区别？

       a.Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法.它有两个常用的子接口，List：对元素都有定义索引,有序的,可以有重复元素.Set：不可以重复元素,是无序的.

       b.Collections是集合框架中的一个工具类,该类中的方法都是静态的.提供的方法中有可以对list集合进行排序，二分查找等方法.

    注意:常用的集合都是线程不安全的,因为要提高效率.如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的.

class  CollectionsDemo
{
	public static void main(String[] args) 
	{
		sortDemo();
	}
	public static void binarySearchDemo()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		Collections.sort(list,new StrLenComparator());//根据指定比较器产生的顺序对指定列表进行排序
		sop(list);
		int index = halfSearch2(list,"aaaa",new StrLenComparator());//使用二分查找法
		sop("index="+index);
	}
	//自定义二分查找的方法
	public static int halfSearch(List<String> list,String key)
	{
		int max,min,mid;
		max = list.size()-1;
		min = 0;
		while(min<=max)
		{
			mid = (max+min)>>1;
			String str = list.get(mid);
			int num = str.compareTo(key);
			if(num>0)
				max = mid -1;
			else if(num<0)
				min = mid + 1;
			else
				return mid;
		}
		return -min-1;
	}
	//根据比较器进行升序排列,再二分查找
	public static int halfSearch2(List<String> list,String key,Comparator<String> cmp)
	{
		int max,min,mid;
		max = list.size()-1;
		min = 0;

		while(min<=max)
		{
			mid = (max+min)>>1;
			String str = list.get(mid);
			int num = cmp.compare(str,key);
			if(num>0)
				max = mid -1;
			else if(num<0)
				min = mid + 1;
			else
				return mid;
		}
		return -min-1;
	}
//获取最大值元素
	public static void maxDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		Collections.sort(list);
		sop(list);
		String max = Collections.max(list);
		sop("max="+max);
	}
	public static void sortDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");		
		sop(list);
		Collections.sort(list,new StrLenComparator());
		sop(list);
		
	}
//定义打印方法
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

//定义比较器
class StrLenComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}

import java.util.*;

class StrComparator implements Comparator<String>
{
	按照与自然顺序相反的顺序进行比较
	public int compare(String s1,String s2)
	{
		return s2.compareTo(s1);
	}
}
//按长度定义比较器
class StrLenComparator implements Comparator<String>
{
	public int compare(String s1,String s2)
	{
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}
class CollectionsDemo2 
{
	public static void main(String[] args) 
	{
		shuffleDemo();
	}
	public static void shuffleDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		list.add("qq");
		list.add("z");
		sop(list);
		Collections.shuffle(list);//使用默认随机源对指定列表进行置换
		sop(list);
	}
	//遍历集合
	public static void orderDemo()
	{
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new StrLenComparator()));
		ts.add("abcde");
		ts.add("aaa");
		ts.add("k");
		ts.add("cc");
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	}
	//替换元素并反转
	public static void replaceAllDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		sop(list);
		Collections.replaceAll(list,"aaa","pp");
		sop(list);
		Collections.reverse(list);
		sop(list);
	}
	//fill方法可以将list集合中所有元素替换成指定元素。
	public static void fillDemo()
	{
		List<String> list = new ArrayList<String>();
		list.add("abcd");
		list.add("aaa");
		list.add("zz");
		list.add("kkkkk");
		
		sop(list);
		Collections.fill(list,"pp");//将集合对象全部替换
		sop(list);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

学习感悟

    这些工具类给操作提供了简便的方法,大部分理解即可.即便工具类使用起来很方便,但学习中比较重要的方法还是要自己掌握比较好,如数组的排序,二分查找等.