Map集合
map集合通过映射的方式来存储数据。
Map<K,V>,数据具有一个键值K，相当于下标，还具有一个数值V。
Map集合的通用方法
添加
put<K,V>:将指定的数据添加到map集合中
删除
remove：删除键值K的数据
判断有无数据
containsKey：判断是否有简直为K的数据，如果有则返回true，没有就返回false
获取指定数据
get:获取指定键值的数据。
Map集合的特殊迭代方法：keySet和entrySet
Map集合没有迭代器，所以我们需要使用set集合中的迭代器来取出数据。
1.keySet方法：将Map集合中的键值取出，生成一个新的Set集合，通过Set集合的迭代器来访问键值取出数据。
HashMap<Integer,String> hm=new HashMap<Integer, String>();
hm.put(1,"A");
hm.put(2,"B");
hm.put(3,"C");
hm.put(4,"D");
Set<Integer> keyset=hm.keySet();
Iterator it=keyset.iterator();
while (it.hasNext())
{
System.out.println(hm.get(it.next()));
}
2.entrySet方法：
HashMap：数据底层是哈希表的Map集合
Map集合的底层数据是哈希表，具有无序，不可重复的特点。
自定义存储HashMap：通过复写equals和hashCode方法。
import java.util.*;
class student
{
private String name;
private int age;
student(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int hashCode()
{
return this.name.hashCode()+this.age*5;
}
public boolean equals(Object obj)
{
if(!(obj instanceof student))
return false;
student s=(student)obj;
return this.name.equals(s.name) && this.age==s.age;
}
}
class HashMapDemo
{
public static void main(String[] args)
{
HashMap<student,String> hm=new HashMap<student,String>();
hm.put(new student("li",12),"nanjing");
hm.put(new student("wang",12),"xi'ann");
hm.put(new student("ni",12),"beijing");
hm.put(new student("li",13),"nanjing");
Set<student> smp=hm.keySet();
Iterator it=smp.iterator();
while(it.hasNext())
{
System.out.println(hm.get(it.next()));
}
}
}
Map的扩展，Map嵌套Map：Map的数据类型中有Map。
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
class keySetDemo
{
public static void main(String[] args)
{
HashMap<String,HashMap<String,String>> collage=new HashMap<String,HashMap<String,String>>();
HashMap<String,String> shanxi =new HashMap<String, String>();
HashMap<String,String> beijing=new HashMap<String, String>();
collage.put("shanxicollage",shanxi);
collage.put("beijingcollage",beijing);
shanxi.put("sxStudent1","sx1");
shanxi.put("sxStudent2","sx2");
shanxi.put("sxStudent3","sx3");
beijing.put("bjStudent1","bj1");
beijing.put("bjStudent2","bj2");
beijing.put("bjStudent3","bj3");
Set<String> key=collage.keySet();
Iterator<String> it=key.iterator();
while (it.hasNext())
{
String place=it.next();
sop(collage.get(place));
}
}
public static void sop(HashMap<String,String> plcollage)
{
Iterator<String> it=plcollage.keySet().iterator();
while(it.hasNext())
{
String place=it.next();
System.out.println(plcollage.get(place));
}
}
}
Map集合参数中含有List集合：
import sun.plugin.viewer.context.IExplorerAppletContext;
import java.util.*;
class student
{
private String name;
private String id;
student(String name,String id)
{
this.name=name;
this.id=id;
}
public String getMessage()
{
return name+"---"+id;
}
}
class keySetDemo
{
public static void main(String[] args)
{
HashMap<String, ArrayList<student>> collage=new HashMap<String,ArrayList<student>>();
ArrayList<student> class1=new ArrayList<student>();
ArrayList<student> class2=new ArrayList<student>();
collage.put("class1",class1);
collage.put("class2",class2);
class1.add(new student("A","01"));
class1.add(new student("B","02"));
class2.add(new student("C","01"));
class2.add(new student("D","02"));
Set<String> key=collage.keySet();
Iterator<String> it=key.iterator();
while (it.hasNext())
{
String classnum=it.next();
System.out.println(classnum);
ArrayList<student> al=collage.get(classnum);
Iterator it2=al.iterator();
while(it2.hasNext())
{
student s=(student) it2.next();
System.out.println(s.getMessage());
}
}
}
}
Collections
Collections中的sort方法
调用此方法，按照自然顺序将List集合中的元素进行排序，它还可以用Comparator接口进行自定义排序。
Collecions.sort(List);
import sun.plugin.viewer.context.IExplorerAppletContext;
import java.io.CharArrayReader;
import java.util.*;
class student
{
private String name;
private String id;
student(String name,String id)
{
this.name=name;
this.id=id;
}
public String getMessage()
{
return name+"---"+id;
}
}
class keySetDemo
{
public static void main(String[] args)
{
ArrayList al=new ArrayList();
al.add("qwe") ;
al.add("qwe4") ;
al.add("qwer") ;
al.add("sadce") ;
al.add("zxc") ;
Collections.sort(al);
System.out.println(al);
Collections.sort(al,new diycompare());
System.out.println(al);
}
}
class diycompare implements Comparator<String>
{
public int compare(String s1,String s2)
{
int num=new Integer(s1.length()).compareTo(s2.length());
if(num==0)
{
return s1.compareTo(s2);
}
return num;
}
}
Collections中的max方法
找出集合中最大的元素，在没有Comparator比较器的时候，它是按照自然顺序的最大元素，如果人为加入Comparator比较器，那么它就会按照比较器中的规则排序，最大值就改变。
ArrayList al=new ArrayList();
al.add("qwe") ;
al.add("qwe4") ;
al.add("qwer") ;
al.add("sadce") ;
al.add("zxc") ;
System.out.println(Collections.max(al));
Collections中的binarySearch（List，“xxx”）方法
该方法二分查找，会查找指定参数，找到，则返回其角标，如果没有，则返回
ArrayList al=new ArrayList();
al.add("qwe") ;
al.add("qwe4") ;
al.add("qwer") ;
al.add("sadce") ;
al.add("zxc") ;
System.out.println(Collections.binarySearch(al,"qwee"));
Collections中的fill（List，“xxx”）方法
将集合所有的数据全部用指定元素替代。
Collections中的replaceAll（List，“old”，“new”）方法
把List集合中所有出现的old值替换成new值。
Collections中的reverse（List）方法
将集合的顺序反转，头变尾，尾变头。
Collections中的reverseOrder类方法
返回一个比较器，逆转所有顺序，这个方法适用于TreeSet这类不具有比较性的数据时，反转，可以对现有的比较器进行反转。
new reverseOrder(new diycompare());
如果diycompare是一个从小到大的比较器，那么这个语句就返回了一个从大到小的比较器。
Arrays工具类
这个工具类用于操作数组，里面的方法全是静态的
Arrays.toString（arr）：将数组转成String类
Arrays.asList（arr）：将数组转成List集合
这个方法如果数组是基本数据类型：比如int，double等，转之后的集合，集合中的元素是这个数组，而不是数组中的元素，也就是说，集合的元素存放的是这个数组的地址。
为什么把数组转成集合？？
因为转成集合之后，很多操作变得简单，比如查找，数组情况下必须遍历数组查找，使用集合的方法直接查找就很方便。
把数组转成集合之后，不可以使用集合的增删方法，因为数组的长度是固定的。
将集合转成数组
Collection的toArray方法
class ArrayDemo
{
public static void main(String[] args)
{
ArrayList<String> al=new ArrayList<String>();
al.add("a");
al.add("b");
al.add("c");
al.add("d");
String[] arr=al.toArray(new String[4]);
System.out.println(Arrays.toString(arr));
}
}
转成数组 可以限制对元素的增删。
增强for循环
对Iterator的简化书写
ArrayList<String> al=new ArrayList<String>();
al.add("a");
al.add("b");
al.add("c");
al.add("d");
for(String s : al)
{
System.out.println(s);
}
可变参数：就是一种高效的参数简写形式，不用每一次都建立对象，也不用定义多个数组，也不用定义多个重载方法。
书写方法：int…arr
如果要定义多个参数，可变参数要定义在后面，否则容易出现问题。
class changedWords
{
public static void main(String [] args)
{
show(1,2,3,4);
}
public static void show(int...arr)
{
System.out.println(arr.length);
}
}
System类
System中的成员都是静态的
System类的特有方法：
System.getProperties();获取系统属性信息
System.setProperties();设定系统属性信息
Properties是Hashtable的子类，可以将其中的信息取出来。
Runtime类
该类中没有提供构造函数，所以不能new子类，本类中的方法都是静态的。
Runtime r=Runtime.getRuntime()
Runtime类中有一个方法，获取Java程序运行时的相关对象，这个对象是程序运行时就建立好的。
本类的其他方法：
exec（“command”）：执行指定命令，返回一个Process类型的值
Process类下有一个方法destroy（）可以杀死所有子进程。
Process q=r.exec("");
q.destroy();
Date类
Date类用于获取时间
获取时间：
Date d=new Date();
这个对象获取了本地时间，但是打印格式是标准格式，如果我们想个性化显示日期，那么还需要用到DateFormat的子类SimpleDateFormat，中的SimpleDateFormat（pattern）方法，该方法的参数pattern是想要显示的格式。
然后SimpleDateFormat新建的子类调用方法format（d），将已经获取到时间的对象d封装成指定格式对象，用字符串来接收，最后打印该字符串就达到了自定义输出格式输出的效果。
public static void main(String[] args)
{
Date d=new Date();
SimpleDateFormat SDF=new SimpleDateFormat("yyyy-MM-dd");
String time =SDF.format(d);
System.out.println(time);
}
Calendar类
根据本地地区建立一个日历，然后利用Calendar.get（）方法来获取想要的日期。
Calendar d=Calendar.getInstance();
System.out.println(d.get(Calendar.DAY_OF_WEEK));
Math
数学方法
Math.ceil(num)：返回大于指定数据的最小整数
Math.floor(num)：返回小于指定数据的最大证书
Math.round(num)：四舍五入数据
Math.pow(a,b)：计算a的b次方
Math.random():返回一个随机值。
Random随机数
Randrom r=new Random();
r.nexrInt(10);返回一个0到10之间的整数
IO流
IO流中的FileWriiter：文件读写
新建一个FileWriter的对象：
FileWriter fw=new FileWriter("ioDemo.txt");
在初始化fw对象时，会在目录下搜索ioDemo.txt这个文件，如果有，就覆盖它，如果没有，就新建这个文件。
现在，fw这个对象就可以使用FileWriter中对文件的读写方法了。
1.向文件中写入数据：
fw.write("strings");
这条语句，向输入流中写入了字符串strings，然而文件中并没有写入它，所以要用 fw.flush()来刷新输入流，将流中的数据刷新到文件中。
fw.close()：刷新流中信息并关闭流，关闭流，并且在之前先调用一次flush（）。
IO流异常处理
由于FileWriter对象新建时，给定的文件目录不一定存在等情况，我们需要对输入流进行异常处理。
class ioDemo
{
public static void main(String[] args)
{
FileWriter fw=null;//将对象建立放到try-catch的外面，这样才能让fw对象作用于整个函数。
try
{
fw=new FileWriter("ioDemo.txt");
fw.write("i am iodemo!");
}
catch(IOException e)
{
System.out.println(e.toString());
}
finally
{
try//对colse进行try，因为可能发生new对象的时候就失败的异常
{
if(fw!=null)//空文件不需要关闭，所以if
fw.close();
}
catch(IOException e)
{
System.out.println(e.toString());
}
}
}
}
在文件输入结束后，要关闭流，所以finally代码块中写close。
文件的续写
在上一次的结尾继续写入数据
fw=new FileWriter("ioDemo.txt",true);
第二个Boolean型参数，如果为true就在文件的末尾进行续写。
文件的读取
FileReader会读取文件中的数据，
read方法每次读一个字符，如果读到了就返回一个正数，没有读到（文件结束）就返回-1
FileReader fr=new FileReader("ioDemo.txt");
int ch;
while((ch=fr.read())!=-1)
{
System.out.println((char)ch);
}
read（arr）可以将文件中的数据读取到数组中。
read（arr）会返回一个整数，这个整数代表着一共读取了多少个字符，所以定义一个数组，长度最好是1024的整数倍，在写入的时候，进行长度的限制。
文件的拷贝
就是对一个文件进行读取，然后写入到另一个文件。
class ioDemo
{
public static void main(String[] args)
{
FileWriter fw=null;
FileReader fr=null;
int num;
char []arr=new char[1024];
try
{
fw=new FileWriter("copy1.txt");
fr=new FileReader("ioDemo.txt");
while((num=fr.read(arr))!=-1)
{
fw.write(arr,0,num);
}
}
catch (IOException e)
{
}
finally
{
try
{
fr.close();
fw.close();
}
catch (IOException e)
{
}
}
}
}
BufferedWriter
缓冲区读入，它是一个提高流效率的方法。
因为提高的是流的效率，所以新建BufferedWriter对象时，要传入流作为参数，在缓冲区关闭的时候，关闭的也是流，所以不用再写流的关闭。
FileWriter fw=new FileWriter("ioDemo.txt");
BufferedWriter bw=new BufferedWriter(fw);
bw.write("okokkokok!");
bw.close();
BufferedReader
FileReader fr=new FileReader("ioDemo.txt");
BufferedReader br=new BufferedReader(fr);
String line=null;
while((line=br.readLine())!=null)
System.out.print(line);
br.close();
这个缓冲区提供了一个更佳的方法，readLine（），读取一行数据，当读取到文件结束，返回null；
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
