java 之API

于 2014-10-19 19:13:26 发布
阅读量528 收藏 1
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjn_yes/article/details/40266003
版权

|--------String类

特点：字符串是一个特殊的对象，一旦被初始化就不可以被改变，String类的初始化的两种方式：

首先创建一个String对象s，然后让s的值为“ABCabc”， 然后又让s的值为“123456”。 从打印结果可以看出，s的值确实改变了。那么怎么还说String对象是不可变的呢？ 其实这里存在一个误区： s只是一个String对象的引用，并不是对象本身。对象在内存中是一块内存区，成员变量越多，这块内存区占的空间越大。引用只是一个4字节的数据，里面存放了它所指向的对象的地址，通过这个地址可以访问对象。 也就是说，s只是一个引用，它指向了一个具体的对象，当s=“123456”; 这句代码执行过之后，又创建了一个新的对象“123456”， 而引用s重新指向了这个心的对象，原来的对象“ABCabc”还在内存中存在，并没有改变。内存结构如下图所示： 
\

(1)  String str="abc";

(2 ) String str1 = new String("abc");

两种方式的区别：

String 对字符串的操作：str 在内存中有一个对象，而str1在内存中有两个对象

==符号和equals的区别：

==是比较两个对象是否相等

equals比较的是地址值，但是String类复写了Object里的equals方法，定义了自己独特内容，该方法用于判断字符串是否相同。


1，获取。
1.1 字符串中的包含的字符数，也就是字符串的长度。
int length():获取长度。
1.2 根据位置获取位置上某个字符。
char charAt(int index):
1.3 根据字符获取该字符在字符串中位置。
int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。
int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。

int indexOf(String str):返回的是str在字符串中第一次出现的位置。
int indexOf(String str, int fromIndex) :从fromIndex指定位置开始，获取str在字符串中出现的位置。

int lastIndexOf(int ch) ：

2，判断。
2.1 字符串中是否包含某一个子串。
boolean contains(str):
特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。
所以，也可以用于对指定判断是否包含。 if(str.indexOf("aa")!=-1)   而且该方法即可以判断，有可以获取出现的位置。
2.2 字符中是否有内容。
boolean isEmpty(): 原理就是判断长度是否为0. 
2.3 字符串是否是以指定内容开头。
boolean startsWith(str);
2.4 字符串是否是以指定内容结尾。
boolean endsWith(str);
2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
boolean equals(str);
2.6 判断内容是否相同，并忽略大小写。
boolean equalsIgnoreCase();
3，转换。
3.1 将字符数组转成字符串。
构造函数：String(char[])
    String(char[],offset,count):将字符数组中的一部分转成字符串。

静态方法：
static String copyValueOf(char[]);
static String copyValueOf(char[] data, int offset, int count) 
static String valueOf(char[]):

3.2  将字符串转成字符数组。**
char[] toCharArray():

3.3 将字节数组转成字符串。
String(byte[])
String(byte[],offset,count):将字节数组中的一部分转成字符串。

3.4 将字符串转成字节数组。
byte[]  getBytes():
3.5 将基本数据类型转成字符串。
static String valueOf(int)
static String valueOf(double)

//3+"";//String.valueOf(3);

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

4，替换（如果要替换的字符不存在，那么返回的还是原来的字符串）
String replace(oldchar,newchar);

5，切割
String[] split(regex);//regex---正则表达式
6，子串。获取字符串中的一部分。
String substring(beginIndex);
String substring(beginIndex,endIndex);
7，转换，去除空格，比较。
7.1 将字符串转成大写或则小写。
 String toUpperCase();
 String toLowerCase();

7.2 将字符串两端的多个空格去除。
String trim();

7.3 对两个字符串进行自然顺序的比较。
int compareTo(string);//接口comparable<String>中的compareTo方法，如果参数字符串等于此字符串就返回0 ，如果此字符串按照
字典的顺序小于字符串参数，则返回一个小于0的值，如果此字符串按照字典顺序大于字符串参数则返回大于0的数。

|------StringBuffer

特点：StringBuffer可以对字符串内容进行增删，它是一个容器，很多方法和String相同，可以操作多个数据类型，通过toString方法变成字符串 区别是：可变长度
1,存储
1.1 StringBuffer  append()  将制定数据作为参数添加到已有数据的结尾处
1.2 StringBuffer insert(index,数据)  可以将数据插入到指定的位置

2，删除。
StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end。
StringBuffer deleteCharAt(index):删除指定位置的字符。

3，获取。
char charAt(int index) 
int indexOf(String str) 
int lastIndexOf(String str) 
int length() 
String substring(int start, int end) 
 
4，修改。
StringBuffer replace(start,end,string);
void setCharAt(int index, char ch) ;

5，反转。
StringBuffer reverse();
 
6，将缓冲区中指定数据存储到指定字符数组中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 



JDK1.5 版本之后出现了StringBuilder.

StringBuffer和StringBuilder的区别：
StringBuffer是线程同步。StringBuilder是线程不同步。以后开发，建议使用StringBuilder
升级三个因素：1，提高效率。2，简化书写。3，提高安全性。


|---------基础数据类型包装类

基本数据类型对象包装类的最常见作用， 就是用于基本数据类型和字符串类型之间做转换
1.基本数据类型对象包装类。

byte Byte
short short
char Character
int Integer
long Long
float Float
double Double
boolean Boolean


2.基本数据类型与字符串之间的转换
1. 基本数据类型转成字符串。

（1）基本数据类型+""

（2）基本数据类型.toString(基本数据类型值); 如： Integer.toString(34);//将34整数变成"34";

2.字符串转成基本数据类型。

（1）xxx a = Xxx.parseXxx(String);

int a = Integer.parseInt("123");//静态调用方式
double b = Double.parseDouble("12.23");
boolean b = Boolean.parseBoolean("true");

（2）Integer i = new Integer("123");int num = i.intValue();//对象调用方式
3.进制之间转换：
十进制转成其他进制。
toBinaryString();（二进制）
toHexString();（八进制）
toOctalString();（十六进制）


其他进制转成十进制。
parseInt(string,radix);参数为字符串和对应的进制

4.基础类型包装类的新特性：
(1) 自动装箱，拆箱：下面是一个例子
//Integer x = new Integer(4);
Integer x = 4;//自动装箱，4是对象相当于new Integer（4）,多了一个null，要进行判断，null没有intValue方法
x=x+2;//x+2:x进行了自动拆箱变成int类型（x.intValue()）和2进行加法运算，然后再将和装箱赋给x
(2) 当数值在byte范围内容。对于新特性，如果该数值已经存在则不会在新开辟空间
Integer a = 127;
Integer b = 127;
sop("a==b:"+(a==b));//结果为true。因为a和b指向了同一个Integer对象。
//因为当数值在byte范围内容。对于新特性，如果该数值已经存在则不会在新开辟空间

|-------集合和框架（重点）
集合类的作用：对对象进行存储
集合类和数组同为容器，有什么不同：数组也可以存储对象，但是长度是固定的，集合长度是可以变的
   数组中可以存储基本的数据类型，集合只能存储对象
集合类的特点：只用于存储对象，集合长度可变，可以存储不同类型对象

集合框架的构成及分类：






出现这么多容器的原因是每一个容器对数据存储的方式不同，这个存储方式成为：数据结构
集合共性方法：add--------参数类型为Object，这样可以接受任何类型对象
     集合中存储的都是对象的引用（地址）
迭代器：Iterator： 把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素而每一个容器的数据结构不同
  所以取出的动作细节也不一样，但是都有共性内容判断和取出，那么就可以写成共性抽取.该规则就是Iterator
通过一个对外的方法iterator()
==============================================

一   Collection
|--List:元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
|--Set：元素是无序，元素不可以重复。
|-------HashSet：底层数据结构是哈希表。是线程不安全的。不同步。通过元素的两个方法，hashCode和equals来完成，保证了元素的唯一性
|-------TreeSet：可以对Set集合中的元素进行排序，（自定义两种排序方式，下面TreeSet有讲解）




1.List：
|-----List
|-----ArrayList
|-----LinkedList
特有方法。凡是可以操作角标的方法都是该体系特有的方法。


增
add(index,element);
addAll(index,Collection);


删
remove(index);


改
set(index,element);
查
get(index):
subList(from,to);
listIterator();
int indexOf(obj):获取指定元素的位置。
ListIterator listIterator();


List集合特有的迭代器。ListIterator是Iterator的子接口。


在迭代时，不可以通过集合对象的方法操作集合中的元素。 因为会发生ConcurrentModificationException异常。
所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的， 只能对元素进行判断，取出，删除的操作，
如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。 该接口只能通过List集合的listIterator方法获取。
例子程序： 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
public class ListIeratorTest {
	public static void main(String[] args) {
		
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		Iterator it = al.iterator();
		while(it.hasNext()){
			//al.add("java05");//这里不能添加元素，因为一边取出，一边添加就会引发并发修改异常java.util.ConcurrentModificationException
			System.out.println(it.next());
		}
		
		
		
		ArrayList all = new ArrayList();
		all.add("java01");
		all.add("java02");
		all.add("java03");
		all.add("java04");
		ListIterator it2 = all.listIterator();
		while(it2.hasNext()){
			Object obj = it2.next();
			if(obj.equals("java02")){
				it2.add("java006");//ListIterator迭代器可以添加和设置Set	
			}
		}
		System.out.println(all);
		while(it2.hasPrevious()){
			System.out.println(it2.previous());
		}	

	}

}








List集合判断元素是否相同，依据是元素的equals方法。


1.1ArrayList：实现了List中所有的方法，增删改查
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。
思路：
1，对人描述，将数据封装进人对象。
2，定义容器，将人存入。
3，取出。 
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	
	public boolean equals(Object obj)
	{

		if(!(obj instanceof Person))
			return false;

		Person p = (Person)obj;
		//System.out.println(this.name+"....."+p.name);

		return this.name.equals(p.name) && this.age == p.age;
	}
	
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class ArrayListTest2 
{
	
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();

		al.add(new Demo());

		al.add(new Person("lisi01",30));//al.add(Object obj);//Object obj = new Person("lisi01",30);
		//al.add(new Person("lisi02",32));
		al.add(new Person("lisi02",32));
		al.add(new Person("lisi04",35));
		al.add(new Person("lisi03",33));
		//al.add(new Person("lisi04",35));

		
		//al = singleElement(al);

		sop("remove 03 :"+al.remove(new Person("lisi03",33)));//remove方法底层也是依赖于元素的equals方法。


		Iterator it = al.iterator();


		while(it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}
	}


	public static ArrayList singleElement(ArrayList al)
	{
		//定义一个临时容器。
		ArrayList newAl = new ArrayList();

		Iterator it = al.iterator();

		while(it.hasNext())
		{
			Object obj = it.next();

			if(!newAl.contains(obj))//调用一次contains运用一次equals
				newAl.add(obj);

		}

		return newAl;
	}
}


1.2LinkedList：
LinkedList:特有方法：
增：
addFirst();
addLast();


getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

删：
removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException




在JDK1.6出现了替代方法。


offerFirst();
offerLast();

peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。

pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。
LinkedList模拟一个堆栈和队列
堆栈：先进后出，队列：先进先出 
import java.util.LinkedList;
public class LinkedQuee {
	public static void main(String[] args) {
		Quee q = new Quee();
		q.myAdd("java01");
		q.myAdd("java02");
		q.myAdd("java03");
		while(!q.isNull()){
			System.out.println(q.myGet());
		}
		
		Zhan z = new Zhan();
		z.myAdd("java01");
		z.myAdd("java02");
		z.myAdd("java03");
		while(!z.isNull()){
			System.out.println(z.myGet());
		}
		
		

	}

}
class Quee{
	public  LinkedList list;
	Quee(){
		list = new LinkedList();
	}
	public void myAdd(Object obj){//每得到一个都放在链表的后面
		list.addLast(obj);
	}
	public Object myGet(){
		return list.removeFirst();//从前面开始取出，就相当于队列了，先进先出
	}
	public boolean isNull(){
		return list.isEmpty();
	}
}

class Zhan{
	public  LinkedList list;
	Zhan(){
		list = new LinkedList();
	}
	public void myAdd(Object obj){
		list.addLast(obj);
	}
	public Object myGet(){
		return list.removeLast();//堆栈，先进后出
	}
	public boolean isNull(){
		return list.isEmpty();
	}
}

1.3vector：

枚举就是Vector特有的取出方式。发现枚举和迭代器很像。其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。
示例： 
import java.util.Enumeration;
import java.util.Vector;


public class VectorTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Vector v = new Vector();
		v.add("01");
		v.add("02");
		v.add("03");
		v.add("04");
		
		Enumeration en = v.elements();//获取元素枚举类型
		while(en.hasMoreElements()){//循环输出元素
			System.out.println(en.nextElement());
		}
		

	}

}



2.Set
|------Set
|-------HashSet
|-------TreeSet
Set：Set集合的功能和Collection是一致的。元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、
2.1    HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashcode值不同，不会调用equals。
 注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
示例：往hasSet集合中存入自定对象，姓名和年龄相同的视为一个人
 
import java.util.HashSet;
import java.util.Iterator;

public class HashSetDemo {

	public static void main(String[] args) {
		HashSet hs = new HashSet();
		hs.add(new Person1("wjn",12));
		hs.add(new Person1("wjn",12));
		hs.add(new Person1("dph",23));
		hs.add(new Person1("jf",28));
		Iterator it = hs.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}
}


class Person1{
	private String name;
	private int age;
	Person1( String name, int age){
		this.name = name;
		this.age = age;
	}
	@Override
	//覆盖hashCode方法，首先保证唯一性
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	//其次覆盖equals方法，当hashCode相同时判断equals保证人员的唯一性
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person1 other = (Person1) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return name+":"+age;
	}
	
}




2.2   TreeSet：可以对Set集合中的元素进行排序，排序的时候，当主要条件相同时，一定要判断一下次要顺序
底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0

TreeSet排序的第一种方式：让元素自身具备比较性。
方法是 元素需要实现Comparable接口，覆盖compareTo方法。
这种方式也成为元素的自然顺序，或者叫做默认顺序。
示例：往TreeSet集合中存储自定义对象学生，按照年龄排序 

import java.util.Iterator;
import java.util.TreeSet;


public class StudentAgeSort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		TreeSet ts = new TreeSet();
		ts.add(new student("lisi02",22));
		ts.add(new student("lisi002",21));
		ts.add(new student("lisi09",23));
		ts.add(new student("lisi08",23));
		//ts.add(new Student("lisi01",28));
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			student stu = (student)it.next();
			System.out.println(stu.getName()+"...."+stu.getAge());
		}

	}

}
class student implements Comparable{
	private String name;
	private int age;
	student(String name,int age){
		this.name=name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	

	@Override
	public String toString() {
		return name+":"+age;
	}

	public int compareTo(Object obj) {
		if(!(obj instanceof student))
			throw new RuntimeException("不是学生对象");
		student s = (student)obj;
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
			return this.name.compareTo(s.name);//String 类实现了compart To方法
		
		return -1;
	}
	
}
TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。
方法是 定义了比较器（定义一个类，实现Comparator接口，覆盖compare方法），将比较器对象作为参数传递给TreeSet集合的构造函数。


示例，比较学生，按照姓名排序： 
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;


public class StudentSort {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		TreeSet ts = new TreeSet(new MyCompare());
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi002",21));
		ts.add(new Student("lisi09",24));
		ts.add(new Student("lisi09",23));
		ts.add(new Student("lisi08",18));
		//ts.add(new Student("lisi01",28));
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"...."+stu.getAge());
		}
	

	}

}
class Student{
	private String name;
	private int age;
	Student(String name,int age){
		this.age=age;
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}


class MyCompare implements Comparator{

	public int compare(Object o1, Object o2) {
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;
		int num = s1.getName().compareTo(s2.getName());
		if(num==0){
			return new Integer(s1.getAge()).compareTo(new Integer (s2.getAge()));
			/**
			if(s1.getAge()>s2.getAge())
				return 1;
			if(s1,getAge()==s2.getAge())
				return 0;
			return -1;
			*/
		}
		return num;
	}
	
}
当两种排序都存在时，以比较器为主。


二  泛型
泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
 
import java.util.ArrayList;
import java.util.Iterator;


public class GenericDemo {

	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		//al.add(4);//al.add(new Integer(4))java.lang.ClassCastException
		
		Iterator it = al.iterator();
		while(it.hasNext()){
			String s = (String)it.next();
			System.out.println(s);
		}

	}

}
通过上面的程序可以发现，我们往集合中存储的类型有String类型，也有Integer类型，但是用迭代器取出的时候全部强制类型转换为String类型，那么就会引发类型转换异常，为了解决这个问题那么就引入了泛型，将上面的代码进行修改，引出泛型
ArrayList<String> al = new ArrayList<String>();
Iterator<String> it = al.iterator<String>();
将运行时期出现的问题，转移到了编译时期，方便程序员解决问题。

1.好处
（1）将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。，
（2）避免了强制转换麻烦。

2.   泛型格式：通过<>来定义要操作的引用数据类型。

3.问题：在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到<>就要定义泛型。其实<> 就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
下面举一个例子，泛型在比较器中的应用： 
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;


public class GenericCompareLen {

	public static void main(String[] args) {
		TreeSet<String> ts = new TreeSet<String>(new LenComparator());
		ts.add("wjn");
		ts.add("jodfjeo");
		ts.add("jf");
		ts.add("fjojfowe");
		Iterator<String> it = ts.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}

}
class LenComparator implements Comparator<String>{

	public int compare(String o1, String o2) {//倒着排序（由短到长，就是将o1,o2换一下位置）
		int num = new Integer(o2.length()).compareTo(new Integer(o1.length()));
		if(num==0)
			return o2.compareTo(o1);
		return num;
	}
	
}



4.泛型类
问题：什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。
比如下面的一个例子： 
public class GenericTest2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//泛型类之前
		/*tool t = new tool();
		t.setW(new Teacher());
		Worker w = (Worker)t.getW();//引发java.lang.ClassCastException类型转换异常
		 */		
		//泛型类之后
		Utils<Teacher> u = new Utils<Teacher>();
		u.setE(new Teacher());
		Teacher teacher = u.getE();//这里取出的时候就是Teacher类型，如果不是编译就无法通过

	}

}
class Worker{
	
}
class Teacher{
	
}
/*class tool{
	private Worker w;

	public Worker getW() {
		return w;
	}

	public void setW(Worker w) {
		this.w = w;
	}
}*/
//泛型类之前是这样做的
class tool{
	private Object w;

	public Object getW() {
		return w;
	}

	public void setW(Object w) {
		this.w = w;
	}
	
}
//泛型类之后的做法
class Utils<E>{
	private E e;

	public E getE() {
		return e;
	}

	public void setE(E e) {
		this.e = e;
	}
	
}


泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。
下面举例说明： 
public class GenericClassAndMethod {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//定义在类上面的时候，类确定类型所有方法都确定
		Demo<String> d = new Demo<String>();
		d.show("类定义的泛型  show");
		d.print("类定义的泛型  print");
		//d.print(4);//编译出错
		
		Demo<Integer> d1 = new Demo<Integer>();
		d1.show(new Integer(4));
		d1.print(9);
		
		
		//定义在方法上的泛型
		Demo1 d2= new Demo1();
		d2.show(new Integer(4));
		d2.print("方法上的泛型");
		

	}

}
class Demo<T>{
	public void show(T t){
		System.out.println("show"+t);
	}
	public void print(T t){
		System.out.println("print"+t);
	}
}

class Demo1{
	public <T>void show(T t){
		System.out.println("show"+t);
	}
	public<Q> void print(Q q){
		System.out.println("print"+q);
	}
}


特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
下面举例说明： 
public class GenericStatic {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Demo3<String> d = new Demo3<String>();
		d.show("hahha");
		//d.show(4);//不行，类型随着类走的
		d.print(4);//可以，因为类随着对象走的

		Demo3.method("jfdlksd");
	}

}
class  Demo3<T>
{
	public void show(T t) 
	{
		System.out.println("show"+t);
	}
	public <Q> void print(Q q)
	{
		System.out.println("print"+q);
	}
	//静态方法不可以访问类上定义的泛型
	/*public static void method(T t)
	{
		System.out.println("method:"+t);
	}*/
	//如果静态方法操作的类型不确定可以将泛型定义在方法上
	public static<W> void method(W t)
	{
		System.out.println("method:"+t);
	}

}

4.泛型接口：可以再接口上定义泛型 
public class GenericInterface {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Inter1 i1 = new Inter1();
		i1.show("类中已经指定类型了");
		
		//类中没有指定类型，测试的时候指定类型
		Inter2<Integer> i2 = new Inter2<Integer>();
		i2.show(4);
		

	}

}
interface Inter<T>
{
	public void show(T t);
}
//实现接口的时候就指定类型
class Inter1 implements Inter<String>{
	public void show(String t)
	{
		System.out.println("SHOW1"+t);
	}
}
//实现接口的时候不指定类型，交给测试程序指定类型
class Inter2<T> implements Inter<T>{
	
	public void show(T t)
	{
		System.out.println("SHOW2"+t);
	}
}



6.? 通配符。也可以理解为占位符。
例如： 
public class GenericWildCard {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Info<Integer> in = new Info<Integer>();
		in.setVar(4);
		shuchu(in);

	}
	public static void shuchu(Info<?> temp){//可以接受任意类型
		System.out.println("Info:"+temp);
	}

}
class Info<T>{
	private T var;

	public T getVar() {
		return var;
	}

	public void setVar(T var) {
		this.var = var;
	}
	public String toString(){
		return var.toString();
	}
}


泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。下限 
public class GenericWildCard {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// ?extends E 演示
		Info<Integer> in = new Info<Integer>();
		Info<Float> in2 = new Info<Float>();
		in.setVar(4);
		in2.setVar(10f);
		shuchu(in);
		shuchu(in2);
		
		//只能接受Number的子类，所以下面的代码出错了
	/*	Info<String> in1 = new Info<String>();
		in1.setVar("nihao");
		shuchu(in1);*/
		
		//? super E 演示
		 Info<String> i1 = new Info<String>() ;   // 声明String的泛型对象  
	        Info<Object> i2 = new Info<Object>() ; // 声明Object的泛型对象  
	        i1.setVar("hello") ;  
	        i2.setVar(new Object()) ;  
	        shuchu2(i1) ;  
	        shuchu2(i2) ;  
		
		

	}
	public static void shuchu(Info<? extends Number> temp){//可以接受Number和Number的子类，其他的不行
		System.out.println("Info:"+temp);
	}
	
	public static void shuchu2(Info<? super String> temp){//可以接受String和String的父类，其他的不行
		System.out.println("Info:"+temp);
	}
	
	

}
class Info<T>{
	private T var;

	public T getVar() {
		return var;
	}

	public void setVar(T var) {
		this.var = var;
	}
	public String toString(){
		return var.toString();
	}
}

三 Map
 
Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
1，添加。
put(K key, V value) 
putAll(Map<? extends K,? extends V> m) 


2，删除。
clear() 
remove(Object key) 


3，判断。
containsValue(Object value) 
containsKey(Object key) 
isEmpty() 




4，获取。
get(Object key) 
size() 
values() 


entrySet() 
keySet() 


Map
|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。




Map和Set很像。其实，Set底层就是使用了Map集合。Map中的key有覆盖的功能，如果一样的key不同的value那么后一个会将前一个覆盖掉

map集合的两种取出方式：
1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。
所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。
举例： 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;


public class MapGet1 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		HashMap<String ,String> m = new HashMap<String,String>();
		m.put("01", "wjn");
		m.put("03", "jfls");
		m.put("02", "dph");
	
		
		Set<String> keySet = m.keySet();
		Iterator<String> it = keySet.iterator();
		while(it.hasNext()){
			String key = it.next();
			String value = m.get(key);
			System.out.println("key:"+key+"..."+"value:"+value);
		}

	}

}


2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：Map.Entry
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢？
因为只有有了Map集合，有了键值对，才会有键值的映射关系。
关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。

举例： 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;


public class MapGet2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		HashMap<String ,String> m = new HashMap<String,String>();
		m.put("01", "wjn");
		m.put("03", "jfls");
		m.put("02", "dph");
		Set <Map.Entry<String, String>>keySet = m.entrySet();
		Iterator<Map.Entry<String, String>> it = keySet.iterator();
		while(it.hasNext()){
			Map.Entry<String, String> map = it.next();
			String key = map.getKey();
			String value = map.getValue();
			System.out.println("key:"+key+"..."+"value:"+value);
		}

	}

}

HashMap保证唯一性的时候需要复写hascode和equals方法
举例：
用HashMap存储学生的，key为学生对象，包括年龄和姓名，value来存储地址。 
import java.util.*;
class MapTest
{
	public static void main(String[] args) 
	{
		HashMap<student,String> hm = new HashMap<student,String>();
		hm.put(new student("lisi",21),"beijing");
		hm.put(new student("lisi",22),"shanghai ");
		hm.put(new student("lisi",23),"tianjing");
		hm.put(new student("lisi",24),"bdfs");

		//第一种取出方式keyset
		Set<student> keySet = hm.keySet();
		Iterator<student> it = keySet.iterator();
		while(it.hasNext())
		{
			student stu = it.next();
			String addr = hm.get(stu);
			System.out.println(stu+","+addr);
		}

		//第二种取出方式
		Set<Map.Entry<student,String>> entrykey = hm.entrySet();
		Iterator<Map.Entry<student,String>> it1 = entrykey.iterator();
		while(it1.hasNext())
		{
			Map.Entry<student,String> me = it1.next();
			student key = me.getKey();
			String value = me.getValue();
			System.out.println(key+":,"+value);

		}
	}
}

class student implements Comparable<student>
{
	private String name;
	private int age;
	student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public int compareTo(student s)
	{
		int num = new Integer(this.age).compareTo(new Integer(s.age));
		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}
	 
	public int hashCode()
	{
		return name.hashCode()+age*34;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof student))
			throw new ClassCastException("类型不匹配");
		student s = (student)obj;
		return this.name.equals(s.name)&&this.age==s.age;


	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name+":"+age;
	}
}

treeMap（有排序的功能）实现compare to方法，保证唯一性
举例：对学生对象的姓名（或者年龄）进行排序 
import java.util.*;

class stuNameComparator implements Comparator<stu>
{
	public int compare(stu s1,stu s2)
	{
		int num = s1.getName().compareTo(s2.getName());
		if(num==0)
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
		return num;
	}
}
class MapTest2 
{
	public static void main(String[] args) 
	{
		TreeMap<stu,String> tm = new TreeMap<stu,String>(new stuNameComparator());//传入类比较器的时候就按姓名排序，不传入的时候就按照年龄排序

		tm.put(new stu("alisi1",23),"beijing");
		tm.put(new stu("lisi2",21),"shanghai ");
		tm.put(new stu("blisi4",24),"tianjing");
		tm.put(new stu("lisi3",22),"bdfs");
		tm.put(new stu("lisi3",22),"bdfs");

		Set<Map.Entry<stu,String>> entrykey = tm.entrySet();
		Iterator<Map.Entry<stu,String>> it = entrykey.iterator();
		while(it.hasNext())
		{
			Map.Entry<stu,String> me = it.next();
			stu stu = me.getKey();
			String addr = me.getValue();
			System.out.println(stu+":::"+addr);

		}
	}
}



class stu implements Comparable<stu>
{
	private String name;
	private int age;
	stu(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public int compareTo(stu s)
	{
		int num = new Integer(this.age).compareTo(new Integer(s.age));
		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}
	 
	public int hashCode()
	{
		return name.hashCode()+age*34;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof stu))
			throw new ClassCastException("类型不匹配");
		stu s = (stu)obj;
		return this.name.equals(s.name)&&this.age==s.age;


	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return name+":"+age;
	}
}

四 集合工具类：Collections，Arrays

1.collections
1.1 collections.sort//对集合进行排序，静态方法
( <T extends  Comparable <? super T>>)void   sort( List<T>list）根据元素的 自然顺序 对指定列表按升序进行排序。
(T)void sort( List<T>list,Comparator<? super T>c）   根据指定比较器产生的顺序对指定列表进行排序。
例子：字符串默认排序,以及按照字符串长度进行排序： 
import java.util.*;
class  CollectionString
{
	public static void main(String[] args) 
	{
		sortDemo();
		
	}
	public static void sortDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("dsf");
		list.add("d");
		list.add("addsf");
		list.add("ggdsf");

		System.out.println(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.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;


public class CollectionSort {
	public static void main(String[] args) {
		ArrayList<student2> al = new ArrayList<student2>();
		al.add(new student2("wjn",25));
		al.add(new student2("jdsf",15));
		al.add(new student2("jdsrtgrf",15));
		al.add(new student2("sf",15));
		Collections.sort(al,new myComparator());
		Iterator<student2> it = al.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}

	}

}
class student2 {
	private String name;
	private int age;
	public student2(String name,int age){
		this.name = name;
		this.age = age;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	student2(String name){
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String toString()
	{
		return name+":"+age;
	}
}
class myComparator implements Comparator<student2>{

	public int compare(student2 o1, student2 o2) {
		if(o1.getName().length()>o2.getName().length())
			return 1;
		if(o1.getName().length()<o2.getName().length())
			return -1;
		return o1.getName().compareTo(o2.getName());
		
	}

}


1.2 collections.max
( <T extends  Comparable <? super T>>)T   sort( List<T>list）根据元素的 自然顺序，返回给定 collection 的最大元素。
(<T>)T sort( List<T>list,Comparator<? super T>c）   根据指定比较器产生的顺序，返回给定 collection 的最大元素。
示例代码同sort一样，添加String max = Collections.max(list,new strLenComparator());即可得到最大值

1.3collections.binarySearch
<T> int      binarySearch(List<? extends Comparable<? super T>> list, T key)   使用二分搜索法搜索指定列表，以获得指定对象。
<T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)使用二分搜索法搜索指定列表，以获得指定对象。
如果没有找到要查找的元素，那么就返回（-插入点-1）（插入点就是这个要找的这个字符串在排好序的字符串的插入位置。）
示例：（包括自定义的二分查找）下面的代码体现了binarySearch的实现过程 

import java.util.*;
class  CollectionsBinarySearch
{
	public static void main(String[] args) 
	{
		 binarySearchDemo();
	}

	public static void binarySearchDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("dsf");
		list.add("d");
		list.add("addsfsdsdf");
		list.add("ggdsf");
		Collections.sort(list,new strLenComparator());
		sop(list);
		//int index = Collections.binarySearch(list,"d");//如果没有找到，那么就返回（-插入点-1）（插入点就是这个要找的这个字符串在排好序的字符串的插入位置。）
		int index = halfSearch2(list,"d",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; //  /2

			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; //  /2

			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 sop(Object obj)
	{
		System.out.println(obj);
	}
}
class lenComparator1 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);
	}
}

1.4 collection.fill
Collections.fill(list,"pp");//将元素全都换为指定元素

1.5collections.reverse

反转集合

 void  reverse(List<?> list)   反转指定列表中元素的顺序。
<T> Comparator<T>   reverseOrder()  返回一个比较器，它强行逆转实现了Comparable 接口的对象 collection 的自然顺序。
<T> Comparator<T> reverseOrder(Comparator<T> cmp)返回一个比较器，它强行逆转指定比较器的顺序。
举例，reverse和reverseOrder 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;

class len 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 CollectionsReverse 
{
	public static void main(String[] args) 
	{
		orderDemo();

	}
	public static void orderDemo()
	{
		//TreeSet<String> ts = new TreeSet<String>(new len());//按照长度由短到长打印
		//TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());//按照字符串默认顺序反序打印
		TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new len()));//按照长度由长到短打印
		ts.add("fsd");
		ts.add("asfdf");
		ts.add("sfsd");
		ts.add("fsdf");

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}

	}


	public static void reverseDemo()
	{
		List<String> list = new ArrayList<String>();

		list.add("dsf");
		list.add("d");
		list.add("addsfsdsdf");
		list.add("ggdsf");
		Collections.reverse(list);//反转
		sop(list);

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


1.6 Collections.replaceAll(list,"dsf","p");//实际是list.set(index,"p")
1.7Collections.swap(list,1,2);//交换list的1角标和2角标的元素
1.8Collections.shuffle(list)//打乱集合，可以应用到扑克牌洗牌算法


2.Arrays
2.1数组变成集合Arrays.asList
好处以及注意：
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法
因为数组的长度是固定的。contains，getindexOf(),subList()这些可以用
如果增删，则会发生UnsupportedOperationException
转换时关系：
int[] nums={2,4,5}; 
List li = Arrays.asList(nums);
sop(li);//[[I@ee67c12]

List<int []> li = Arrays.asList(nums);
sop(li);//[[I@ee67c12]

//Integer[] nums = {2,4,5};
List<Integer> li =  Arrays.asList(nums);
sop(li);//[2,4,5]
总结：
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素
如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在

2.2集合变数组：toCharArray(),Arrays.toString
重要问题：
1.指定类型的数组到底要定义多长呢？
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size
当指定的类型的数组长度大于了集合的size，就不会新创建了数组。而使用传递进来的数组。
所以创建一个刚刚好的数组最优。

2，为什么要将集合变数组？
为了限定对元素的操作（不让别人增删，只让别人查询）
用法：存在集合list al 
  String[] arr = al.toArray(new String[al.size()]);
   System.out.println(Arrays.toString(arr));

五jdk1.5 新特性
1.增强for循环
1.1 高级for循环格式：
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{

}
1.2   对集合进行遍历（迭代器和增强for循环的区别） 。
只能获取集合元素。但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
1.3 传统for和高级for有什么区别呢？
高级for有一个局限性。必须有被遍历的目标。
建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。
2.可变参数（方法的可变参数。在使用时注意：可变参数一定要定义在参数列表最后面。）
可变参数其实就是上一种数组参数的简写形式。不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。隐式将这些参数封装成了数组。
比如：
public static void show(String str,int... arr)
{
System.out.println(arr.length);
}
3.静态导入
3.1当类名重名时候需要指定具体的包名
3.2当方法重名时，指定具备所属的对象或者类
比如：
import static java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员

|------>System
不能被实例化：
System:类中的方法和属性都是静态的。
out:标准输出，默认是控制台。
in：标准输入，默认是键盘。
描述系统一些信息。
获取系统属性信息：Properties getProperties();
例子程序：System的一些常用操作 
import java.util.Properties;


public class SystemDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Properties  p = System.getProperties();
		//因为properties 是 hashtable 的子类，也就是Map集合的一个子类对象
		//那么可以通过map的方法取出该集合中的元素
		//该集合中存储的都是字符串，没有泛型定义
		
		//如何在系统中自定义一些特有信息呢？
		System.setProperty("myKey", "myValue");
		
		//获取指定属性信息
		String value = System.getProperty("os.name");
		System.out.println("value:"+value);
		
		
		//可不可以在jvm启动时，动态加载一些属性呢
		String v = System.getProperty("myKey");
		System.out.println("v:"+v);
		
		/*//获取所有属性信息
		for(Object obj:p.keySet()){
			String value1 = (String) p.get(obj);
			System.out.println(obj+"..."+value1);
		}
*/
	}

}

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


public class RuntimeDemo {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws IOException, InterruptedException {
		// TODO Auto-generated method stub
		Runtime r = Runtime.getRuntime();
		//Process p=r.exec("C:\\Program Files\\EditPlus 3\\EditPlus.exe");//打开相应的文件
		Process p = r.exec("notepad.exe  SystemDemo.java");打开笔记本，显示RuntimeDemo文件内容
		Thread.sleep(4000);
		p.destroy();//显示4秒之后自动关闭
	

	}

}
|------->Date日期类型 
import java.text.SimpleDateFormat;
import java.util.Date;


public class DateDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Date d = new Date();
		System.out.println(d);//Wed Oct 29 20:53:27 CST 2014打印的时间看不懂，希望有些格式。
		
		//将模式封装到SimpleDateformat对象中。
		SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss ");
		String x = s.format(d);
		System.out.println(x);//2014-10-29 08:53:27 
		
		
		long l = System.currentTimeMillis();//返回以毫秒为单位的当前时间。
		Date d1 = new Date(l);//参数date：date - 不超过 year 8099 的毫秒表示的自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数。负数指示在 1970 年 1 月 1 日 00:00:00 GMT 之前的毫秒数。
		//如果给定毫秒值包含时间信息，则驱动程序会将时间组件设置为对应于零 GMT 的默认时区（运行应用程序的 Java 虚拟机的时区）中的时间。 
		System.out.println("d1:"+d1);//d1:Wed Oct 29 20:55:00 CST 2014
		
	}

}
|----->Calendar 
import java.util.Calendar;


public class CalendarDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Calendar c = Calendar.getInstance();
		System.out.println(c.get(Calendar.YEAR)+"年");
		System.out.println(c.get(Calendar.MONTH)+1+"月");
		System.out.println(c.get(Calendar.DAY_OF_MONTH)+"日");
		System.out.println("星期"+(c.get(Calendar.DAY_OF_WEEK)-1));
		
		
		
	String[] mons = {"一月","二月","三月","四月",
					"五月","六月","七月","八月",
					"九月","十月","十一月","十二月"};
	String[] weeks = {"","星期日","星期一","星期二","星期三",
						"星期四","星期五","星期六",};
	int index = c.get(Calendar.MONTH);
	int index1 = c.get(Calendar.DAY_OF_WEEK);
	System.out.println(mons[index]);
	System.out.println(weeks[index1]);

	}

}
|----->Math.random 
import java.util.*;
class  MathDemo
{
	public static void main(String[] args) 
	{
		Random r = new Random();
		for(int x = 0;x<10;x++)
		{
			//int d = (int)(Math.random()*10+1);//随机数
			int d = r.nextInt(10)+1;
			System.out.println(d);
		}
		


	}
	public static void show()
	{
		double d = Math.ceil(12.34);//ceil 返回大于指定数据的最小整数
		double d1 = Math.floor(12.34);//返回小于指定数据的最大整数

		long l = Math.round(12.34);//四舍五入

		sop("l="+l);
		sop("d="+d+",d1="+d1);

		double d2 = Math.pow(2,3);//幂运算
		sop("d2="+d2);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
切割与合并文件：（重要） 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;


public class splitDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		//splitFile();
		merge();
	}
	//合并
	public static void merge() throws IOException{
		FileOutputStream fo = new FileOutputStream("0.jpg");
		ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
		for(int x = 1; x<4;x++){
			FileInputStream fi = new FileInputStream("E:\\java练习\\wjnfuxi\\suipian\\"+x+".part");
			al.add(fi);
		}
		final Iterator<FileInputStream> it = al.iterator();
		Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){

			public boolean hasMoreElements() {
				return it.hasNext();
			}

			public FileInputStream nextElement() {
				
				return it.next();
			}
			
		};
		SequenceInputStream ss = new SequenceInputStream(en);
		byte[] buf = new byte[1024];
		int len = 0;
		while((len = ss.read(buf))!=-1)
		{
			fo.write(buf,0,len);
		}
		fo.close();
		ss.close();
	}
	public static void splitFile() throws IOException{//切割
		FileInputStream fi = new FileInputStream("1.jpg");
		FileOutputStream fo = null;
		byte buf[] = new byte[1024*300];
		int len = 0;
		int count = 1;
		while((len = fi.read(buf))!=-1){
			fo = new FileOutputStream("E:\\java练习\\wjnfuxi\\suipian\\"+(count++)+".part");
			fo.write(buf, 0, len);
			fo.close();
		}
		fi.close();
	}

}

3.9操作对象：
ObjectInputStream与ObjectOutputStream被操作的对象需要实现Serializable（标记接口）
意义：对象本身存在对内存当中，当程序运行完之后，就会垃圾回收处理了，可以通过流的方式将对内存中的对象存入到硬盘上，
把对象存到硬盘上就叫做对象的可持久化，可序列化 
import java.io.*;
class Person implements Serializable//标记接口
{
	static final long serialVersionUID=42;//保证id号一致，为了序列化方便，新的类还能操作曾经被序列化的对象
	private String name;
	transient int age;//age也没有序列化（在堆内存存在，不在文件中存在）
	static String country="cn";//静态的不能被序列化。cn不会被传进来的数改变
	Person(String name,int age,String country)
	{
		this.name = name;
		this.age = age;
		this.country=country;
	}
	public String toString()
	{
		return name+"::"+age+":"+country;
	}
}

class ObjectStreamDemo 
{
	public static void main(String[] args) throws Exception
	{
		//writeObject();
		readObj();
	}
	public static void readObj()throws Exception
	{
		ObjectInputStream ols = new ObjectInputStream(new FileInputStream("obj.txt"));
		Person p = (Person)ols.readObject();
		System.out.println(p);
	}
		public static void writeObject()throws Exception
	{
			ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
			oos.writeObject(new Person("zhangsan",15,"kr"));
			oos.close();

	}
}
3.9：RandomAccessFile
随机访问文件，自身具备读写方法，通过skipByte(int x),seek(int x)来达到随机访问
管道流
PipedInputStream和PipedOutputStream ，输入输出可以直接进行连接，通过结合线程使用










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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值