java_集合
Collection
|--List:元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
|--Set：元素是无序，元素不可以重复。、
1，添加
add(e);
addAll(collection);
2，删除
remove(e);
removeAll(collection);
clear();
3，判断。
contains(e);
isEmpty();
4，获取
iterator();
size();
5，获取交集。
retainAll();
6，集合变数组。
toArray();
7,查
get(index):
subList(from,to);
listIterator();
intindexOf(obj):获取指定元素的位置。
ListIteratorlistIterator();
1，add方法的参数类型是Object。以便于接收任意类型对象。
2，集合中存储的都是对象的引用(地址)
迭代器是取出方式，会直接访问集合中的元素。
所以将迭代器通过内部类的形式来进行描述。
通过容器的iterator()方法获取该内部类的对象。
在迭代时循环中next调用一次，就要hasNext判断一次。
Iteratorit = al.iterator();
while(it.hasNext())
{
sop(it.next()+"...."+it.next());
}
LinkedList:特有方法：
addFirst();
addLast();
getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。
|--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、
|--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
Set集合的功能和Collection是一致的。
枚举就是Vector特有的取出方式。
其实枚举和迭代是一样的。
class VectorDemo
{
publicstatic void main(String[] args)
{
Vectorv = new Vector();
v.add("chrp01");
v.add("chrp02");
v.add("chrp03");
v.add("chrp04");
Enumeration en = v.elements();
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}
Set:无序，不可以重复元素。
|--HashSet：数据结构是哈希表。线程是非同步的。
保证元素唯一性的原理：判断元素的hashCode值是否相同。
如果相同，还会继续判断元素的equals方法，是否为true。
|--TreeSet：可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据：
compareTo方法return 0.
TreeSet排序的第一种方式：让元素自身具备比较性。
元素需要实现Comparable接口，覆盖compareTo方法。
也种方式也成为元素的自然顺序，或者叫做默认顺序。
TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。
排序时，当主要条件相同时，一定判断一下次要条件。
按照字符串长度排序。使用比较器。
class TreeSetTest
{
publicstatic void main(String[] args)
{
TreeSetts = new TreeSet(new StrLenComparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iteratorit = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class StrLenComparator implementsComparator
{
publicint compare(Object o1,Object o2)
{
Strings1 = (String)o1;
Strings2 = (String)o2;
intnum = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
returns1.compareTo(s2);
returnnum;
}
}
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
泛型格式：通过<>来定义要操作的引用数据类型。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
class GenericDemo
{
publicstatic void main(String[] args)
{
ArrayList<String>al = new ArrayList<String>();
al.add("abc01");
al.add("abc0991");
al.add("abc014");
Iterator<String>it = al.iterator();
while(it.hasNext())
{
Strings = it.next();
System.out.println(s+":"+s.length());
}
}
}
? 通配符。也可以理解为占位符。
泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。下限
public static voidprintColl(Collection<? extends Person> al)
{
Iterator<?extends Person> it = al.iterator();
while(it.hasNext())
{
System.out.println(it.next().getName());
}
}
将字符串中的数值进行排序。使用TreeSet完成。因为TreeSet自身具备排序功能。
class TreeSetTest
{
publicstatic void main(String[] args)
{
ArrayListal = new ArrayList();
Stringstr = "90 -7 0 18 2 45 4";
String[] arr = str.split(" ");
TreeSetts = new TreeSet();
for(intx=0; x<arr.length; x++)
{
ts.add(Integer.parseInt(arr[x]));//
}
System.out.println(ts);
}
}
Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
1，添加。
put(Kkey, V value)
putAll(Map<?extends K,? extends V> m)
2，删除。
clear()
remove(Objectkey)
3，判断。
containsValue(Objectvalue)
containsKey(Objectkey)
isEmpty()
4，获取。
get(Objectkey)
size()
values()
entrySet()
keySet()
Map
|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
Set底层就是使用了Map集合。
import java.util.*;
class MapDemo
{
publicstatic void main(String[] args)
{
Map<String,String>map = new HashMap<String,String>();
//添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。
//并put方法会返回被覆盖的值。
System.out.println("put:"+map.put("01","zhangsan1"));
System.out.println("put:"+map.put("01","wnagwu"));
map.put("02","zhangsan2");
map.put("03","zhangsan3");
System.out.println("containsKey:"+map.containsKey("022"));
System.out.println("get:"+map.get("023"));
map.put("04",null);
System.out.println("get:"+map.get("04"));
//可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断。
//获取map集合中所有的值。
Collection<String>coll = map.values();
System.out.println(coll);
System.out.println(map);
}
}
map集合的两种取出方式：
1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。
所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。
2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：Map.Entry
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部，
因为只有有了Map集合，有了键值对，才会有键值的映射关系。
关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。
对学生对象的年龄进行升序排序。
import java.util.*;
class StuNameComparator implementsComparator<Student>
{
publicint compare(Student s1,Student s2)
{
intnum = s1.getName().compareTo(s2.getName());
if(num==0)
returnnew Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
returnnum;
}
}
class MapTest2
{
publicstatic void main(String[] args)
{
TreeMap<Student,String>tm = new TreeMap<Student,String>(new StuNameComparator());
tm.put(newStudent("blisi3",23),"nanjing");
tm.put(newStudent("lisi1",21),"beijing");
tm.put(newStudent("alisi4",24),"wuhan");
tm.put(newStudent("lisi1",21),"tianjin");
tm.put(newStudent("lisi2",22),"shanghai");
Set<Map.Entry<Student,String>>entrySet = tm.entrySet();
Iterator<Map.Entry<Student,String>>it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<Student,String>me = it.next();
Studentstu = me.getKey();
Stringaddr = me.getValue();
System.out.println(stu+":::"+addr);
}
}
}
集合框架的工具类。
Collections:集合框架的工具类。里面定义的都是静态方法。
Collections和Collection的区别是：
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口，
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序。
Collections是集合框架中的一个工具类。该类中的方法都是静态的
提供的方法中有可以对list集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
集合变数组。
Collection接口中的toArray方法。
import java.util.*;
class CollectionToArray
{
publicstatic void main(String[] args)
{
ArrayList<String>al = new ArrayList<String>();
al.add("abc1");
al.add("abc2");
al.add("abc3");
//1,指定类型的数组的长度：
//当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。//长度为集合的size。
// 当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进//来的数组。
// 所以创建一个刚刚好的数组最优。
// 2,为什么要将集合变数组？
// 为了限定对元素的操作。不需要进行增删了。
String[]arr = al.toArray(new String[al.size()]);
System.out.println(Arrays.toString(arr));
}
}
---------------------------------------------------------
System:类中的方法和属性都是静态的。
out:标准输出，默认是控制台。
in：标准输入，默认是键盘。
描述系统一些信息。
获取系统属性信息：PropertiesgetProperties();
import java.util.*;
class SystemDemo
{
publicstatic void main(String[] args)
{
Propertiesprop = System.getProperties();
//因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。
//那么可以通过map的方法取出该集合中的元素。
//该集合中存储都是字符串。没有泛型定义。
//如何在系统中自定义一些特有信息呢？
System.setProperty("mykey","myvalue");
//获取指定属性信息。
Stringvalue = System.getProperty("os.name");
System.out.println("value="+value);
//可不可以在jvm启动时，动态加载一些属性信息呢？
Stringv = System.getProperty("haha");
System.out.println("v="+v);s
//获取所有属性信息。
for(Objectobj : prop.keySet())
{
Stringvalue = (String)prop.get(obj);
System.out.println(obj+"::"+value);
}
}
}
-----------------------------
Runtime对象
该类并没有提供构造函数。
说明不可以new对象。该类中的方法都是静态的。
该类中还有非静态方法。
说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。
由这个特点可以看出该类使用了单例设计模式完成。
该方式是staticRuntime getRuntime();
class RuntimeDemo
{
publicstatic void main(String[] args) throws Exception
{
Runtimer = Runtime.getRuntime();
Processp = r.exec("notepad.exe SystemDemo.java");
}
}
-----------------------------------------------
获取当前时间：
Date d = new Date();
System.out.println(d);//打印的时间看不懂，希望有些格式。
//将模式封装到SimpleDateformat对象中。
SimpleDateFormatsdf = new SimpleDateFormat("yyyy年MM月dd日E hh:mm:ss");
//调用format方法让模式格式化指定Date对象。
Stringtime = sdf.format(d);
System.out.println("time="+time);
longl = System.currentTimeMillis();
Dated1 = new Date(l);
System.out.println("d1:"+d1);
---------------------------------------------------------------------
字符流和字节流：
字节流两个基类：
InputStream OutputStream
字符流两个基类：
Reader Writer
既然IO流是用于操作数据的，
那么数据的最常见体现形式是：文件。
在硬盘上，创建一个文件并写入一些文字数据。
找到一个专门用于操作文件的Writer子类对象。FileWriter。 后缀名是父类名。 前缀名是该流对象的功能。
import java.io.*;
class FileWriterDemo
{
publicstatic void main(String[] args) throws IOException
{
//创建一个FileWriter对象。该对象一被初始化就必须要明确被操作的文件。
//而且该文件会被创建到指定目录下。如果该目录下已有同名文件，将被覆盖。
//其实该步就是在明确数据要存放的目的地。
FileWriterfw = new FileWriter("demo.txt");
//调用write方法，将字符串写入到流中。
fw.write("abcde");
//刷新流对象中的缓冲中的数据。
//将数据刷到目的地中。
//fw.flush();
//关闭流资源，但是关闭之前会刷新一次内部的缓冲中的数据。
//将数据刷到目的地中。
//和flush区别：flush刷新后，流可以继续使用，close刷新后，会将流关闭。
fw.close();
}
}
------------------------------------------------
对已有文件的数据续写。
import java.io.*;
class FileWriterDemo3
{
publicstatic void main(String[] args) throws IOException
{
//传递一个true参数，代表不覆盖已有的文件。并在已有文件的末尾处进行数据续写。
FileWriterfw = new FileWriter("demo.txt",true);
fw.write("nihao\r\nxiexie");
fw.close();
}
}
----------------------------------
//读取一个.java文件，并打印在控制台上。
import java.io.*;
class FileReaderTest
{
publicstatic void main(String[] args) throws IOException
{
FileReader fr = newFileReader("DateDemo.java");
char[]buf = new char[1024];
intnum = 0;
while((num=fr.read(buf))!=-1)
{
System.out.print(newString(buf,0,num));
}
fr.close();
}
}
