黑马程序员——Java基础：工具类、for循环、可变参数、其他类

于 2015-06-26 22:16:14 发布
阅读量481 收藏 1
点赞数
分类专栏： Java学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012770105/article/details/46654591
版权

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

 

一、集合框架的工具类之Collections

Collections：类中方法全部是静态的。没有封装特有数据。不需要创建对象。

示例：我们通过该示例来演示Collections工具类中的常见方法的使用。

import java.util.*;
class StrLenComp implements Comparator<String>
{
	public int compare(String str1,String str2)
	{
		//System.out.println(str1+":::"+str2);
		return str1.length()-str2.length();
	}
}
class CollectionsDemo1712 
{
	public static void main(String[] args) 
	{
		List<String> list=new ArrayList<String>();
		list.add("zhangsansan");
		list.add("lisi");
		list.add("wangwu");
		list.add("zhaoliu");
		list.add("qianba");
		list.add("qianliu");

		Collections.sort(list);//排序
		print(list);

		Collections.sort(list,new StrLenComp());//通过比较器，按长度排序
		print(list);

		sop(Collections.max(list));//获取集合中的最大值
		sop(Collections.binarySearch(list,"wangwu"));//二分查找，前提：集合要有序

		Collections.replaceAll(list,"liu","pp");//将集合中的元素"liu"全部替换成qq
		print(list);

		Collections.reverse(list);//反转
		print(list);

		//强行逆转，实现了compareable接口对象的Collection的自然顺序，即ts集合打印的是自然顺序的反转
		TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder());
		ts.add("zhangsansan");
		ts.add("lisi");
		ts.add("wangwu");
		ts.add("zhaoliu");
		ts.add("qianba");
		ts.add("qianliu");
		print(ts);

		//强行逆转指定比较器的顺序
		TreeSet<String> ts1=new TreeSet<String>(Collections.reverseOrder(new StrLenComp()));
		ts1.add("zhangsansan");
		ts1.add("lisi");
		ts1.add("wangwu");
		ts1.add("zhaoliu");
		ts1.add("qianba");
		ts1.add("qianliu");
		print(ts1);

		Collections.swap(list,1,2);//swap只对List进行操作，交换1,2位置上的元素
		print(list);

		Collections.shuffle(list);//随机置换，相当于重新洗牌
		print(list);

		Collections.fill(list,"qq");//将集合中的所有元素全部替换成qq
		print(list);
	}
	public static void print(Collection list) 
	{
		Iterator li=list.iterator();
		while(li.hasNext())
		{
			System.out.println(li.next());
		}
		System.out.println("======================");
	}
	public static void sop(Object obj) 
	{
		System.out.println(obj);
	}
}

运行结果为：

二、集合框架的工具类之Arrays

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

常用方法：

1.将数组转成字符串

   如：int[ ] arr={1,2,3}; 

          Arrays.toString(arr);

2.将数组转成List集合

   如：String[ ] arr={"asd","sde","saa"};

           List<String> list=Arrays.asList(arr);

把数组转成List集合有什么好处呢？

可以使用集合的思想和方法来操作数组中的元素。但要注意：将数组转换成集合后，不可以使用集合中的增删方法。

注：a).如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转为集合中的元素。

           如：String[ ] arr={"asd","sde","saa"};  List<String> list=Arrays.asList(arr);

       b).如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

           如：int[ ] arr={1,2,3}; List<int[ ]> list=Arrays.asList(arr);

3.集合变数组

     Collection接口中有toArray()方法可以将集合变数组。

示例：

import java.util.*;
class ArraysDemo1714 
{
	public static void main(String[] args) 
	{
		ArrayList<String> al=new ArrayList<String>();
		al.add("zhangsansan");
		al.add("lisi");
		al.add("wangwu");
		al.add("zhaoliu");
		al.add("qianba");
		al.add("qianliu");
		String[] arr=al.toArray(new String[0]);
		System.out.println(Arrays.toString(arr));
	}
}

运行结果为：

注：

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

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

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

     所以创建一个刚刚好的数组最优。可将上述示例中的new String[0]改为：new String[al.size]

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

     为了限定对元素的操作。不需要进行增删了。

三、高级for循环

高级for循环：是对集合进行遍历。只能获取集合元素。但是不能对集合进行操作。可以看作是迭代器的简写形式。但是迭代器除了遍历，还可以进行remove集合中元素的动作。如果使用ListIterator，还可以在遍历过程中对集合进行增删改查的操作。

格式：

       for(数据类型变量名 :被遍历的集合（collection）或者数组) {执行语句}

高级for和传统for的区别：

      高级for有一个局限性。必须有被遍历的目标（集合或数组）。

      传统for遍历数组时有索引。

      建议在遍历数组的时候，还是希望使用传统for。因为传统for可以定义角标。

示例：演示高级for的使用。

import java.util.*;
class ForDemo 
{
	public static void main(String[] args) 
	{
		Map<Integer,String> mp=new HashMap<Integer,String>();
		mp.put(1,"nanjing");
	    mp.put(4,"beijing");
		mp.put(2,"nanjing");
		mp.put(5,"shanghai");
	    mp.put(3,"shenzhen");
		mp.put(6,"beijing");
		mp.put(8,"nanjing");

		//方式一：
	    Set<Integer> in=mp.keySet();
		for(Integer i:in)
		{
			String value=mp.get(i);
			System.out.println(i+"::::"+value);
		}
		System.out.println("===================");
		//方式二：
		Set<Map.Entry<Integer,String>> ss=mp.entrySet();
		for(Map.Entry<Integer,String> s:ss)
		{
			Integer i=s.getKey();
			String str=s.getValue();
			System.out.println(i+"::::"+str); 
		}
	}
}

运行结果为：

四、可变参数

如果一个方法在参数列表中传入多个参数，个数不确定，这时可以用数组作为形式参数。在JDK1.5版本之前，要传入参数时，每次都需要定义一个数组对象，作为实际参数传入。但在JDK1.5版本后提供了一个新特性：可变参数。不用每一次都手动的建立数组对象，只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。可变参数其实就是数组参数的简写形式。

在使用时注意：可变参数一定要定义在参数列表的最后面。

示例：演示可变参数的使用

class ChangeParamDemo 
{
	public static void main(String[] args) 
	{
		show("Hello World!",2,3,4,5,6);
	}
	public static void show(String str,int... arr)//可变参数定义在参数列表的最后面
	{
		System.out.println(str+"::::"+arr.length);
	}
}

运行结果为：

五、静态导入

例如：import static java.util.Arrays.*; //导入的是Arrays这个类中的所有的静态成员。

           import static java.lang.System.*; //导入的是System这个类中的所有的静态成员。

注：当类名重名时，需要指定具体的包名。

       当方法重名时，指定具体所属的对象或者类。

六、System类

System：是描述系统一些信息的类，类中的方法和属性都是静态的。

常用成员：

    1.Properties getProperties()：获取系统信息。返回的键值对，因为Properties是Hahstable的子类，也就是Map集合的一个子类

对象，那么可以通过Map方法取出该集合中的元素。该集合存储的都是字符串，没有泛型定义。

    2.out：标准输出流。默认是控制台。

    3.in：标准输入流。默认是键盘。

示例：演示System类的使用

import java.lang.*;
import java.util.*;
class SystemDemo 
{
	public static void main(String[] args) 
	{
		System.setProperty("myKey","myValue");//在系统中自定义特有信息
		Properties pro=System.getProperties();//获取系统信息
		for(Object obj:pro.keySet())
		{
			System.out.print((String)pro.get(obj));
		}
		System.getProperty("os.name");//获取指定属性信息
	}
}

注：在dos中可输入：java -D(key)=(value) //可在jvm启动时，动态地加载一些属性信息。

七、Runtime对象

该类中并没有提供构造函数。说明不可以new对象。那么会直接想到该类中的方法都是静态的。查阅API文档发现，该类中还有非静态方法，说明该类肯定会提供了方法获取本来对象。而且该方法是静态的，并返回值类型是本来类型。该方法就是：static Runtime getRuntime()，由这个特点可以看出该类使用了单例设计模式完成。

 示例：演示Runtime对象的使用

import java.io.*;
class RuntimeDemo 
{
	public static void main(String[] args) throws Exception
	{
		Runtime r=Runtime.getRuntime();//获取Runtime类对象
		Process p=r.exec("notepad.exe ShopThread148.java");//在记事本中打开文件
		Thread.sleep(3000);//让线程等待3秒
		p.destroy();//取消子进程
	}
}

八、时间类——Date，Calendar

Date：获取时间。java中的默认显示格式为：Sat Jun 27 17:29:41 CST 2015

定义时间模式的步骤：

       1）创建Date对象

      2）将时间模式封装到SimpleDateFormat对象中

      3）调用format方法让格式化模式指定Date对象

示例：演示Date类的使用

import java.text.*;
import java.util.*;
class DateCalendar 
{
	public static void main(String[] args) throws ParseException
	{
		Date d=new Date();//创建Date对象
		System.out.println(d);
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy年M月d日 hh:mm:ss");//将时间模式封装到SimpleDateFormat对象中
		String s=sdf.format(d);//调用format方法让格式化模式指定Date对象
		System.out.println(s);

		Date dd=sdf.parse(s);//把时间格式的String时间转成Date类型时间
		System.out.println(dd);
	} 
}

运行结果为：

Calendar：获取时间。是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH等日历字段之间的转换提供了一些方法。可以对年月日等时间进行获取。并提供了相应的子段值。可参阅API文档。

示例：演示Calendar类的使用

import java.text.*;
import java.util.*;
class DateCalendar 
{
	public static void main(String[] args) throws ParseException
	{
		Calendar c=Calendar.getInstance();
		sop(c.get(Calendar.YEAR)+"年");//获取年份
		sop((c.get(Calendar.MONTH)+1)+"月");//获取月份
		sop(c.get(Calendar.DAY_OF_MONTH)+"日");//获取日期
		sop("星期"+(c.get(Calendar.DAY_OF_WEEK)-1));//获取星期
		sop(c.get(Calendar.HOUR_OF_DAY)+"小时");//获取小时
		sop(c.get(Calendar.MINUTE)+"分钟");//获取分钟
		sop(c.get(Calendar.SECOND)+"秒数");//获取秒数
		sop("==============");
		c.add(Calendar.YEAR,-1);//根据日历的规则，为给定的日历字段添加或减去指定的时间量
        sop(c.get(Calendar.YEAR));

		c.set(Calendar.MONTH,12);//将给定日历字段对应的时间值设置为给定值
		sop((c.get(Calendar.MONTH)+1)+"月");//获取月份

		c.set(2016,2,12);// 设置日历字段 YEAR、MONTH和DAY_OF_MONTH的值
		Date d=c.getTime();
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy年M月d日");
		sop(sdf.format(d));

	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

运行结果为：

练习：

/*需求：1.获取任意年的二月有多少天
          思路：根据指定年设置一个时间
		  c.set(year,2,1)//某一年的3月1日
		  c.add(Calendar.DAY_OF_MONTH,-1),//3月1日，往前推一天，就是2月最后一天
        2.获取昨天的现在这个时刻
		  思路：c.add(Calendar.DAY_OF_WEEK,-1)
*/
import java.text.*;
import java.util.*;
class  Date1804
{
	public static void main(String[] args) 
	{
		getDay(2016);
		getZuoTian();		
	}
	//获取任意年的二月有多少天
	public static void getDay(int year)
	{ 
		Calendar c=Calendar.getInstance();
		c.set(year,2,1);
		c.add(Calendar.DAY_OF_MONTH,-1);
		System.out.println(year+"年的二月有"+c.get(Calendar.DAY_OF_MONTH)+"天");
	}
	//获取昨天的现在这个时刻
	public static void getZuoTian()
	{
		Calendar c=Calendar.getInstance();
		c.add(Calendar.DAY_OF_WEEK,-1);
		Date d=new Date();
		SimpleDateFormat sdf=new SimpleDateFormat("hh:mm:ss");
		String time=sdf.format(d);
		System.out.println("昨天的现在这个时刻："+time);
	}
}

运行结果为：

九、Math对象，Random对象

Math：提供了操作数学运算的方法，都是静态的。

示例：演示Math类的使用

class MathDemo 
{
	public static void main(String[] args) 
	{
		double d1= Math.ceil(-16.34);//返回大于指定数据的最小整数
		double d2= Math.floor(-16.34);//返回小于指定数据的最大整数
		double d3= Math.pow(2,3);//返回a的b次方
		long d4= Math.round(3.54);//返回b四舍五入的值
		int d5=0;
		for(int i=0;i<10;i++)
		{
			//返回正号的double值，是一个大于等于0.0且小于1.0的随机数
			d5=(int) Math.random()*10+1;//取1~10之间的随机数。
		}
		sop(d1+":::"+d2+":::"+d3+":::"+d4+":::"+d5);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

运行结果为：


Random：获取随机数。与Math中的random方法是一样的，不过这个类有自身的方法，可以将相应的随机数强转为指定基本数据类型。

示例：演示Random类的使用

import java.util.*;
class RandomDemo 
{
	public static void main(String[] args) 
	{
		Random r=new Random();
		for(int i=0;i<10;i++)
		{
			int d=r.nextInt(10)+1;//获取1~10之间的随机数
			double d2 = (int)(r.nextDouble() * 6 + 1);
			System.out.println(d+"::::"+d2);
		}
	}
}
<span style="font-size:14px;">
</span>

运行结果为：

 

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

幻化
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值