-----------android培训、java培训、java学习型技术博客、期待与您交流！------------
集合框架的工具类
Collections：给集合提供更多的功能，都是静态方法，不需要创建对象，直接调用即可
1、常用方法：
*Collections.sort(list) :对list集合进行自然顺序的排序
*Collections.sort(list,new MyCompare()) :按指定的比较器方法对list集合排序
class MyCompare implements Comparator<String>
{
public intcompare(String s1,String s2)
{
int x =s1.length()-s2.length();
returnx==0?s1.compareTo(s2):x;
}
}
*Collections.max(list) :返回list集合中自然顺序最大的元素
*int index=Collection.binarySearch(list,”kk”):使用二分法查找，返回角标。条件要先用sort进行排序
*Collections.reverseOrder() : 返回一个比较器，它强行逆转实现了 Comparable 接口的对象collection 的自然顺序
*Collections.shuffle(list) :随机对list中的元素进行位置的置换
2、将非同步集合转成同步集合的方法：XXXsynchronizedXXX(XXX)
*List synchronizedList(list)
*Map synchronizedMap(map)
3、Collection和Collections的区别
1）Collections是java.util下的类，是针对集合的一个工具类，提供一系列静态方法，实现对集合的查找、替换、线程安全化（将非同步转换为同步）等操作
2）Collection是java.util下的接口，它是各种集合结构的父接口，只要有List和Set，提供了关于集合的一些操作，例如添加、删除、判断、遍历等
//Collections 练一练
import java.util.*;
class CollectionsLian
{
public static void fuc (Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("bc");
al.add("z");
al.add("acc");
al.add("adec");
al.add("bcddd");
al.add("abc");
fuc(al);
Collections.sort(al);//按元素的自然顺序排序
fuc(al);
int index = Collections.binarySearch(al,"z");//使用二分法查找元素z在al中的位置
fuc(index);
Collections.sort(al,new myCompare());// 按指定的比较器比较
fuc(al);
Collections.reverse(al);
fuc(al);
Collections.shuffle(al);//随机调换al中的元素位置
fuc(al);
fuc(Collections.max(al));//返回al中自然顺序最大
fuc(Collections.min(al));//返回al中自然顺序最小的
}
}
class myCompare implements Comparator<String>
{
public int compare(String s1,String s2)
{
if(s1.length()>s2.length())
return 1;
if(s1.length()==s2.length())
return s1.compareTo(s2);
else
return -1;
}
}//自定义二分法查找
import java.util.*;
class CollectionsDemo1
{
public static void fuc(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc");
al.add("c");
al.add("ac");
al.add("abcd");
al.add("abced");
Collections.sort(al);//对List集合进行自然顺序的排序
fuc(al);
int i = Collections.binarySearch(al,"ac");//直接调用Collections的二分法查找方法，集合先要是有序
fuc(i);
int x = half(al,"ac");
fuc(x);
}
public static int half(ArrayList<String> al,String key)//自定义二分法擦找判断对象在集合中是否存在
{
int max,min,mid;//定义三个变量
max=al.size();//初始化max值为集合的最后一个对象角标
min=0;
while(min<=max)
{
mid =(min+max)>>1;//mid等于最大值加最小值除2
String s =al.get(mid);//获取中间值角标对应的对象
int num = s.compareTo(key);//比较中间值角标对象和设定的对象是否相同
if(num>0)
{
max=mid-1;//如果中间值角标的对象大于设定的，max值就等于mid-1，逐渐缩小查找范围
}
else if(num<0)//如果中间值角标对象小于设定值，min值等于mid加一，
{
min=mid+1;
}
else
return mid;//如果相等就说明找到了，直接放回mid
}return -min-1; //不存在返回设定对象的插入点加一在取反
}
}import java.util.*;
class CollectionsDemo2
{
public static void fuc(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//fillDemo();
//replaceAllDemo();
orderDemo();
}
public static void orderDemo()
{
TreeSet<String> ts = new TreeSet<String>( Collections.reverseOrder());//逆转对象自然顺序 也可以调用手写的 new Com()比较器；还可以反向一个手写比较器
ts.add("abc");
ts.add("cad");
ts.add("bec");
ts.add("bbc");
Iterator it = ts.iterator();
while(it.hasNext())
{
fuc(it.next());
}
}
public static void replaceAllDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
fuc(list);
Collections.replaceAll(list,"aaa","ccc");//将aaa替换为ccc
fuc(list);
Collections.reverse(list);//反转集合
fuc(list);
}
/*
练习：fill方法可以将List集合中所有的元素替换成指定元素
要求：将List集合中部分元素替换成指定元素
*/
public static void fillDemo()
{
List<String> list = new ArrayList<String>();
list.add("abcd");
list.add("aaa");
list.add("zz");
list.add("kkkkk");
fuc(list);
Collections.fill(list,"mm");
fuc(list);
}
}
class Com implements Comparator<String>
{
public int compare(String s1,String s2)
{
return s2.compareTo(s1);
}
}
java.util.*
Arrays：用于操作数组对象的工具类，里面都是静态方法
1、数组转集合
*asList方法：将数组转成List集合
String[] str = {“abc”,”aaa”,”sss”};
List<String> list = Array.asList(str);//将str数组转成List集合
好处：可以通过List集合中的方法来操作数组中的元素：isEmpty()、contains()、indexOf()、set()。
注意(局限性)：数组的长度是固定的，不可以使用集合对象进行增加、删除等。会改变数组长度方法如add、remove、clear(会报不支持操作异常UnsupportedOperationException)
如果数组中存储的引用数据类型，直接作为集合的元素可以直接运用集合的方法操作
如果数组中存储的是基本数据类型，asList会将数组实体作为集合元素存在。
/*
Arrays：用于操作数组的工具类，里面都是静态方法，用于对数组元素的排序sort、查找binarySearch、和转换为字符串 toString
asList：将数组变成List集合
*/
import java.util.*;
class ArraysDemo
{
public static void fuc(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
String[] arr = {"abc","bcd","cccc"};
/*
把数组变成List集合有什么害处？
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增，删方法
因为数组的长度是固定的，否则编译失败
*/
List<String> list = Arrays.asList(arr);
fuc(list.contains("abc"));
/*
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素
如果数组中的元素是基本数据类型，那么就会将该数组作为集合中的元素存在
*/
int[] i = {2,3,4};//数组中的元素为基本数据类型
Integer[] in ={2,3,5};//数组在的元素为对象
List<Integer> ls = Arrays.asList(in);
fuc(ls);
}
}
2、集合变数组
*用的是Collection接口中的方法：toArray();
如果给toArray传递的指定类型的数组长度小于了集合的size，那么toArray方法，会自动再创建一个该类型的数组，长度为集合的size
如果传递的指定类型的数组的长度大于了集合的size，那么toArray方法，就不会创建新数组，直接使用该数组即可，并将集合中的元素存储到数组中，其它空余位值为null，所以，在传递指定类型的数组时，最好的方式就是指定数组的长度和size相等
好处：限定了集合中的元素进行增删操作，只需获取这些元素即可
/*
集合变数组
Collection中的 toArray()方法
*/
import java.util.*;
class ArraysDemo1
{
public static void main(String[] args)
{
ArrayList<String> al = new ArrayList<String>();
al.add("abc");
al.add("bcd");
al.add("cba");
/*
1、指定类型的数组到底要多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组，长度为集合的size
当指定类型的数组长度大于了集合的size，那么就不会创建数组了，而是使用传递进来的数组
所以创建一个刚刚好的数组最优
2、为什么要让集合变数组？
为了限定对元素的操作，不需要进行增删了
*/
String[] arr = al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(arr));
}
}
JDK1.5新特性——增强for循环
Collection在jdk1.5以后，有了一个父类接口Iterable，这个接口的出现将iterator方法进行了抽取，提高了扩展性。
——————————————————————
1、方法：增强for循环：foreach语句，foreach简化了迭代器
格式：增强for循环括号里写两个参数，第一个是声明一个变量，第二个是需要迭代的容器
for(元素类型 变量 ： Collection集合&数组){----}
2、高级for循环与传统for循环区别
1）高级for循环在使用时，必须要明确被遍历的目标。这个目标可以是Collection集合或者数组，如果遍历Collection集合，在遍历过程中还需要对元素进行操作，比如删除，就必须要使用迭代器了
2）如果遍历数组，还需要对数组元素进行操作，建议使用传统for循环，因为可以定义角标，通过角标操作元素。如果只为遍历获取，就可以简化成高级for循环，它的出现简化了书写
3、高级for循环不可以遍历Map集合。但是可以将Map转换为Set后就可以使用
4、常见的使用方式及使用之一事项
1）作用：对存储对象的容器进行迭代：数组 Collection Map
2）增强for循环迭代数组
String[] str ={“abc”,”sss”,”ccc”};
for(String s : str){
System.out.println(s);
}
3）单列集合Collection
List list = new ArrayList();
list.add(“aaa”);
list.add(“ccc”);
//增强for循环，没有使用泛型的集合能不能用增强for循环迭代？ 能
for(Object obj : list){
String str =(String)obj;
System.out.println(str);
}
4）双列集合Map
Map<String,String> map = newHashMap<String,String>();
map.put(“01”,”aaa”);
//传统的两种取出元素的方式 重点掌握
Set<String> keyset = map.keySet();
for(Iterator<String> it =keyset.iterator();it.hasNext();){
String key = it.next();//取出存在set集合中的所有键
String value = map.get(key);//通过键获取值
}
//第二种
Set<Map.Entry<String,String>> entry= map.entrySet();
for(Iterator<Map.Entry<String,String>> it =entry.iterator();it.hasNext();){
Map.Entry<String,String> me =it.next(); //取出存放于set集合中左右的键值对
String key = me.getKey();
String value = me.getValue();
}
//增强for循环迭代：原则上map集合是无法使用增强for循环类迭代的，因为增强for循环只针对实现了Iterable接口的集合进行迭代；Iterable是JDK1.5中新定义的接口，就一个方法Iterator，只有实现了Iterable接口的类，才能保证一定有iterator方法，java有这样的限定是因为增强for循环内部还是用迭代器实现的，实际上我们可以通过某种方式来使用增强for循环
for(Object obj : map.entrySet()){
Map.Entry me =(Entry)obj;
System.out.println(me.getKey()+”...”+me.getValue())
5）集合迭代注意问题：在集合迭代过程中，不能使用集合的方法进行增删操作(会报并发修改异常)；可以使用迭代器的方法进行操作。list集合特有迭代器listIterator有增删操作
6）增强for循环注意问题：使用增强for循环时，不能对元素进行赋值
int[] arr ={1,2,3}
for(int x : arr){
x=0; //错误操作
}
可变参数
1、符号 (...) 三个点就代表是可变参数
2、可变参数：其实就是数组的简写格式，不用每次都建立数组对象，只要将操作的元素作为数组传递即可，隐式将这些参数封装成了数组
3、注意：可变参数一般要定义在参数列表的最后面
/*
JDK1.5版本出现的新特性
可变参数 ：...
注意：可变参数一定要定义在参数列表的最后面
*/
class ParamMethodDemo
{
public static void main(String[] args)
{
/*
可变参数：其实就是数组的简写格式
不用每次都建立数组对象
只要将操作的元素作为数组传递即可
隐式将这些参数封装成了数组
*/
show("String",2,3,4,5,6);
//show(2,3,4,5,6,8,5,4);
}
public static void show(String str,int... arr)
{
int sum =0;
System.out.println(arr.length);
for(int x=0;x<arr.length;x++)
{
sum+=arr[x];
}
System.out.println(sum);
}
}
静态导入
1、静态导入：StaticImport 导出类中的所有静态成员，在调用时不需要写 类名. 直接写方法名就行，简化了静态成员的书写
/*
静态导入：StaticImport
当类名重名时，需要指定具体的包名
当方法重名时，需要指定具体所属的对象或者类
*/
import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays这个类所有的静态成员
class StaticImport //extends Object
{
public static void main(String[] args)
{
int[] arr = {1,4,2,5};
sort(arr);
int x = binarySearch(arr,2);
System.out.println(x);
System.out.println(Arrays.toString(arr));//这里的Arrats.不能去掉，因为Object也有toString方法
} //去掉了会认为是调用Object里面的toString方法
}
其他对象API：
java.lang.System
1、System 类包含一些有用的类字段和方法。属性和行为都是静态的它不能被实例化。
2、方法：
*long currentTimeMillis(); //返回当前时间的毫秒值
*exit(); //退出虚拟机
*PropertisgetPropertis(); //获取当前的系统信息
ProPerties prop = System.getProPerties(); //获取系统信息，并将这些信息存储properties集合中，它是Hashtable的子类，属于Map集合。
System.setProperties(“myName”,”lisi”); //给系统属性信息添加具体的信息
//临时设置方法：运行JVM时，也可以通过JVM的参数进行系统属性的临时设置，可以在java命令后面加入-DmyName=lisi 用法：java –DmyName=lisi 执行类名
*String name = System.getProperties(“os.name”); //获取系统类型名称 win7
//判断该系统是否是某一个软件支持的系统
Set<String>set = new HashSet<String>();
set.add(“WindowsXP”);
set.add(“Windows7”);
if(set.contains(name));
System.out.println(“支持”);
else
System.out.println(“不支持”);
/*
System:类中的方法和属性都是静态的
out：标准输出，默认控制台
in：标准输入 ，默认键盘
描述系统一些信息
获取系统属性信息：ProPerties getProperties
*/
import java.util.*;
class SystemDemo
{
public static void main(String[] args)
{
Properties prop = System.getProperties();
//因为Propertis是Hashtable的子类，也就是Map集合的一个子类对象
//那么可以用Map的方法取出该集合中的元素
//该集合中存储的是字符串，没有定义泛型
for(Object obj:prop.keySet())
{
String value = (String)prop.get(obj);
System.out.println(obj+"::"+value);
}
//如何在系统中自定义一些特有信息
System.setProperty("maykey","mayValue");
//获取指定属性信息
String value = System.getProperty("os.name");//获取系统名称
System.out.println("value="+value);
// 在jvm启动时，动态加载一些属性信息
String v = System.getProperty("haha");
System.out.println("v="+v);//java -Dhaha=aaaaa SystemDemo 会打印出v的值为aaaaa（通过—D的方式）
}
}
java.lang.Runtime
1、Runtime类中没有构造方法，不能创建对象，但是又有非静态方法，可以想到该类肯定提供了获取本类对象的方法，而且该方法是静态的，返回值是Runtime类型。这个方法就是static Runtime getRuntime(); 由上述特点可以看出该类使用了单例设计模式
2、基本应用：
class RuntimeDemo
{
public static void main(String[] args) throws Exception
{
Runtime r = Runtime.getRuntime();
Process p = r.exec("notePad.exe SystemDemo.java");//用记事本打开程序
//Process p = r.exec("E:\\Program Files\\KuGou\\KGMusic\\KuGou.exe");
//Thread.sleep(4000);//让主线程等待4秒
//p.destroy();//杀死打开程序
}
}
java.util.Math
1、Math类是用于数学运算的工具，属性和行为都是静态的，该类是final，不允许被继承
2、方法：
*static double ceil(double a); //返回大于指定数值的最小整数
*static double floor(double a); //返回小于指定数值的最大整数
*static long round(long a); //四舍五入成整数
*static double pow(double a,double b); //a的b次方
*static double random(); //返回0-1的伪随机数
/*
数值计算的工具类：
*/
import java.util.*;
class MathDemo
{
public static void main(String[] args)
{
//show();
Random r = new Random();//随机数
for(int x=0;x<10;x++)
{
//int d = (int)(Math.random()*10+1);//使用Random类就不需要进行强转了
int d = r.nextInt(10);
fuc(d);
}
}
public static void show()
{
double d = Math.ceil(14.22);//ceil返回大于指定数据的最小整数
double d1 = Math.floor(12.23);//floor返回小于指定数据的最大整数
long l = Math.round(16.66);//四舍五入
fuc("d="+d);
fuc("d1="+d1);
fuc("l="+l);
double d2 = Math.pow(2,3);//2的3次方
fuc("d2="+d2);
}
public static void fuc(Object obj)
{
System.out.println(obj);
}
}java.util.Date 日期类
1、日期对象和毫秒值之间的转换
1）日期对象转成毫秒值。Date类中的getTime方法
Date d = new Date();
long time1 = d.getTime();
long time2 = System.currentTimeMillis();//毫秒值
2）如何将获取到的毫秒值转成具体的日期：Date类中的setTime方法。也可以通过构造函数方式。
long time = 122342714376222;
Date d = new Date();
d.setTime(time);
2、将日期字符串转成日期对象：使用的DataFormat方法中的 Dataparse(String source);
//方法一 自定义格式化
public static void method()Throws Exception{
String time = “2014/12/20”;
DateFormat df = new SimpleDateFormat(“yyyy年MM月dd日”);//SimpleDataFormat作为可以指定用户自动以的格式来完成格式化
Date d = df.parse(time);
}
//方法二：如果不需特定的格式化风格，完全可以使用DateFormat类中的静态方法获取集体的已经封装好的方法：getInstance() getDateTimeInstance();
Date d = new Date();
DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
df = DateFormat.getDateTimeInstance(Dateformat.LONG,DateFormat.LONG);
String time = df.format(d);
//将日期对象转换成字符串的方式：DateFormat类中的format方法
//创建日期格式对象
DateFormat df = newSimpleDateFormat();//该对象的建立会封装一个默认的日期格式——14-12-20 下午16:00
//如果想要自定义日期格式的话。可以使用SimpleDateFormat 的构造函数，将具体的格式作为参数传入到构造函数
Date d = new Date();
DateFormat df = new SimpleDateFoemat(“yyyy年MM月dd日 HH:mm:ss”);
//调用DateFormat中的format方法，对已有的日期对象进行格式
String time = df.format(d)
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);
}
}
java.util.Calendar 日历类
import java.util.*;
import java.text.*;
class CalendarDmeo
{
public static void fuc(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Calendar c = Calendar.getInstance();
String[] mons = {"一月","二月","三月","四月",
"五月","六月","七月","八月",
"九月","十月","十一月","十二月"};
String[] weeks ={"","星期日","星期一","星期二","星期三",
"星期四","星期五","星期六"};
int index = c.get(Calendar.MONTH);//计算机的月份是0-11
int index1 = c.get(Calendar.DAY_OF_WEEK);//1-7对应星期日到星期六
fuc(c.get(Calendar.YEAR)+"年");
//fuc((c.get(Calendar.MONTH)+1)+"月");
fuc(mons[index]);//获取月份的角标，查表
fuc(c.get(Calendar.DAY_OF_MONTH)+"日");
//fuc("星期"+c.get(Calendar.DAY_OF_WEEK));
fuc(weeks[index1]);//获取星期的角标，
}
}*/
import java.util.*;
class CalendarDemo2
{
public static void fuc(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Calendar c = Calendar.getInstance();
//c.set(2015,2,4);
c.add(Calendar.DAY_OF_MONTH,10);//时间量的偏移，可以是年月日
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);
fuc(c.get(Calendar.YEAR)+"年");
//fuc((c.get(Calendar.MONTH)+1)+"月");
fuc(mons[index]);
fuc(c.get(Calendar.DAY_OF_MONTH)+"日");
//fuc("星期"+c.get(Calendar.DAY_OF_WEEK));
fuc(weeks[index1]);
}
}/*
两个练习：
1、获取任意年的2月有多少天
思路：根据指定年设置一个时间就是
c.set(year,2,1)//某一年的3月1日
c.add(Calendar.DAY_OF_MONTH,-1)//3月1日往前推一天，就是2月的最后一天，也就是2月的天数
2、获取昨天的现在这个时刻
c.add(Clendar.DAY_OF_MONTH,-1)现在这个时刻减去一天
*/
import java.util.*;
class CalendarTest
{
public static void fuc(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
Calendar c = Calendar.getInstance();
getTime(c);
getDays(c);
}
public static void getDays(Calendar c)
{
c.set(2020,2,1);//设置时间为2020.3.1
c.add(Calendar.DAY_OF_MONTH,-1);//减去一天获得2月的最后一天
fuc(c.get(Calendar.DAY_OF_MONTH));//打印2月的最后一天
}
public static void getTime(Calendar c)
{
c.add(Calendar.DAY_OF_MONTH,-1);
fuc(c.get(Calendar.DAY_OF_MONTH)+"日"+c.get(Calendar.HOUR_OF_DAY)+"时"+c.get(Calendar.MINUTE)+"分");
}
}
80
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
