API,集合

第十三天
Java API是运行库的集合，它提供了一套访问主机系统资源的标准方法。即给开发人员使用的现成方法。

String类
字符串是一个特殊的对象。
String str  = “abc”;//s1是一个类类型变量， "abc"是一个对象。
     //字符串最大特点：一旦被初始化就不可以被改变。
String str1 = new String(“abc”);//两个对象。
String类适用于描述字符串事物。
那么它就提供了多个方法对字符串进行操作。

常见的操作有哪些？
"abcd"

1，获取。
 1.1 字符串中的包含的字符数，也就是字符串的长度。
  int length():获取长度。
 1.2 根据位置获取位置上某个字符。
  char charAt(int index)://当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。
 1.3 根据字符获取该字符在字符串中位置。
  int indexOf(int ch):返回的是ch在字符串中第一次出现的位置。
  int indexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。
           //如果没有找到，返回-1.
  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);(正则表达式)

6，子串。获取字符串中的一部分。
 String substring(begin);//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。
 String substring(begin,end);//包含头，不包含尾。s.substring(0,s.length());

7，转换，去除空格，比较。
 7.1 将字符串转成大写或则小写。
   String toUpperCase();
   String toLowerCase();

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

 7.3 对两个字符串进行自然顺序的比较。
  int compareTo(string);

StringBuffer是字符串缓冲区。
是一个容器。
特点：
1，长度是可变化的。
2，可以字节操作多个数据类型。
3，最终会通过toString方法变成字符串。
1，存储。
 StringBuffer append():将指定数据作为参数添加到已有数据结尾处。
 StringBuffer insert(index,数据):可以将数据插入到指定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是线程不同步。

以后开发，建议使用StringBuilder

升级三个因素：
1，提高效率。
2，简化书写。
3，提高安全性

第十四天
集合
集合框架：
-Collection
  --List ：元素是有序的，元素可以重复。因为该集合体系有索引。
    ---ArrayList ：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
    ---LinkedList ：底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
    ---Vector ：底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
  --Set ：元素是无序，元素不可以重复。
    ---HashSet 底层数据结构是哈希表。是线程不安全的。不同步。    
    ---TreeSet 可以对Set集合中的元素进行排序,底层数据结构是二叉树。    
为什么出现这么多的存储方式都不同。
应为每一个容器对数据的存储方式都不同。
这个存储方式称之为：数据结构。
Collection方法：
添加元素： boolean add(E e)
删除元素： void clear() 清除所有元素
     boolean remove(Object o) 删除单个。
判断元素： boolean contains(Object o) 是否包含指定的元素
     boolean isEmpty() 是否不包含元素
获取：
 迭代器： Iterator<E> iterator()
             返回在此 collection 的元素上进行迭代的迭代器。
   
    Iterator 迭代器里的方法：
    boolean hasNext() ：如果仍有元素可以迭代，则返回 true。    
    E next() ：返回迭代的下一个元素。  
    void remove() ：从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。
迭代器使用方法：   
import java.util.*;
class  CollectionDemo//编译的时候会有注意提示，因为没有定义泛型
{
 public static void main(String[] args)
 {  
  method_get();
      
 }
 public static void method_get()
 {
  ArrayList al = new ArrayList();
  al.add("java01");
  al.add("java02");
  al.add("java03");
  al.add("java04");
  
  Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。
  while(it.hasNext())
  {
   it.next();
   it.remove();
   //System.out.println(it.next());
  }
   System.out.println(al+"...");
  //for循环替代上面,内存优化,迭代器对象只使用一次就自动释放。
  /*for(Iterator it = al.iterator(); it.hasNext() ; )
  {
   sop(it.next());
  }
  */
 }
}
理解迭代器：就如游戏机房里的夹娃娃机器，那个机器里外面的操作杆就是迭代器，
   我们只需要操操作杆就可以取出里面的东西。
其实就是定义在集合里的一个内部类接口 Iterator ，对外界提供一个获取内部类对象的方法iterator()。
然后通过该对象里的方法获取集合里的元素等操作。

List：
 特有方法。凡是可以操作角标的方法都是该体系特有的方法。
增
 void add(index,element);在列表的指定位置插入指定元素
 boolean addAll(index,Collection);将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
删
 E remove(index);移除列表中指定位置的元素
改
 E set(index,element);用指定元素替换列表中指定位置的元素
查
 E get(index): 返回列表中指定位置的元素
 List<E> subList(int fromIndex, int toIndex);返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
 int indexOf(obj):获取指定元素的位置。
    ListIterator<E> listIterator();List特有迭代器，返回此列表元素的列表迭代器（按适当顺序）。
     可以添加元素void add(E e)
List集合特有的迭代器。ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。
所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，
只能对元素进行判断，取出，删除的操作，
如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。
该接口只能通过List集合的listIterator方法获取。

Vector 特有迭代
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
枚举郁郁而终了。

LinkedList:特有方法：
void addFirst(E e);将指定元素插入此列表的开头
addLast();

E getFirst();返回此列表的第一个元素
E getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

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

在JDK1.6出现了替代方法。
boolean offerFirst(E e);在此列表的开头插入指定的元素
offerLast();

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

E pollFirst();
E pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null

HashSet ：
HashSet是如何保证元素唯一性的呢？
      是通过元素的两个方法，hashCode和equals来完成。
      如果元素的HashCode值相同，才会判断equals是否为true。
      如果元素的hashcode值不同，不会调用equals。
      注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
自定义存储：
往hashSet集合中存入自定对象
姓名和年龄相同为同一个人，重复元素。

class HashSetTest {public static void sop(Object obj){System.out.println(obj);}public static void main(String[] args) {HashSet hs = new HashSet();hs.add(new Person("a1",11));hs.add(new Person("a2",12));hs.add(new Person("a3",13));//hs.add(new Person("a2",12));//hs.add(new Person("a4",14));//sop("a1:"+hs.contains(new Person("a2",12)));//hs.remove(new Person("a4",13));Iterator it = hs.iterator();while(it.hasNext()){Person p = (Person)it.next();sop(p.getName()+"::"+p.getAge());}}}class Person{private String name;private int age;Person(String name,int age){this.name = name;this.age = age;}public int hashCode(){System.out.println(this.name+"....hashCode");return name.hashCode()+age*37;}public boolean equals(Object obj)//覆写了比较方法{if(!(obj instanceof Person))return false;Person p = (Person)obj;System.out.println(this.name+"...equals.."+p.name);return this.name.equals(p.name) && this.age == p.age;}public String getName(){return name;}public int getAge(){return age;}}

 

第十五天
TreeSet :
保证元素唯一性的依据：
    compareTo方法return 0.

TreeSet排序的第一种方式：让元素（对象）自身具备比较性。
 元素需要实现Comparable接口，覆盖compareTo方法。
 这种方式也称为元素的自然顺序，或者叫做默认顺序。
 int compareTo(T o)
          比较此对象与指定对象的顺序
代码实现：

class TreeSetDemo {public static void main(String[] args) {TreeSet ts = new TreeSet();ts.add(new Student("lisi02",22));ts.add(new Student("lisi007",20));ts.add(new Student("lisi09",19));ts.add(new Student("lisi08",19));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 int compareTo(Object obj){//return 0;if(!(obj instanceof Student))throw new RuntimeException("不是学生对象");Student s = (Student)obj;System.out.println(this.name+"....compareto....."+s.name);if(this.age>s.age)return 1;if(this.age==s.age){return this.name.compareTo(s.name);}return -1;}public String getName(){return name;}public int getAge(){return age;}}

TreeSet的第二种排序方式。
 当元素自身不具备比较性时，或者具备的比较性不是所需要的。
 这时就需要让集合自身具备比较性。
 在集合初始化时，就有了比较方式。
 TreeSet(Comparator<? super E> comparator)
          构造一个新的空 TreeSet，它根据指定比较器进行排序
 Comparator:
  int compare(T o1, T o2)
          比较用来排序的两个参数。
  boolean equals(Object obj)
          指示某个其他对象是否“等于”此 Comparator。
代码实现：

class TreeSetDemo {public static void main(String[] args) {TreeSet ts = new TreeSet(new MyCompare);//将比较器传入,是集合更具比较器进行比较ts.add(new Student("lisi02",22));ts.add(new Student("lisi007",20));ts.add(new Student("lisi09",19));ts.add(new Student("lisi08",19));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 int compareTo(Object obj){//return 0;if(!(obj instanceof Student))throw new RuntimeException("不是学生对象");Student s = (Student)obj;System.out.println(this.name+"....compareto....."+s.name);if(this.age>s.age)return 1;if(this.age==s.age){return this.name.compareTo(s.name);}return -1;}public String getName(){return name;}public int getAge(){return 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版本以后出现新特性。用于解决安全问题，是一个类型安全机制。

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

泛型格式：通过<>来定义要操作的引用数据类型。
ArrayList<String> al = new ArrayList<String>();
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，
只要见到<>就要定义泛型。
其实<> 就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型来完成扩展
泛型前：

class Tool{private Object obj;public void setObject(Object obj){this.obj = obj;}public Object getObject(){return obj;}}

泛型后：

class Utils<T>{private T q;public void setObject(T q){this.q = q;}public T getObject(){return q;}}

泛型类注意：

class Demo<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){}//静态方法不可以访问类上定义的泛型。public  static <W> void method(W t)//如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。{System.out.println("method:"+t);}}

泛型定义在接口上。
interface Inter<T>
{
 void show(T t);
}

? 通配符。也可以理解为占位符。
泛型的限定；
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。下限

-Map<K,V>
 --Hashtable :线程安全，速度慢，底层是哈希表数据结构，不允许存放null键，null值，已被HashMap替代
    用作键的对象必须实现 hashCode 方法和 equals 方法。
 --HashMap :线程不安全，速度快，底层是哈希表数据结构，允许存放null键，null值。
   用作键的对象必须实现 hashCode 方法和 equals 方法。
 --TreeMap :对键进行排序，底层是二叉树数据结构,排序原理与TreeSet相同。
 和Set很像。其实大家，Set底层就是使用了Map集合。

Map与Collection在集合框架中属并列存在
Map存储的是键值对
Map存储元素使用put方法，Collection使用add方法
Map集合没有直接取出元素的方法，而是先转成Set集合，在通过迭代获取元素
Map集合中键要保证唯一性

1，添加。
  V put(K key, V value)
  void putAll(Map<? extends K,? extends V> m)

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

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

 4，获取。
  V get(Object key)
  int size() 返回此映射中的键-值映射关系数。
  Collection<V> values() 返回此映射中包含的值的 Collection 视图。

  Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。
  Set<K> keySet() 返回此映射中包含的键的 Set 视图。

map集合的两种取出方式：
1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。
 所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
 Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。
 public static void main(String[] args)
 {
  Map<String,String> map = new HashMap<String,String>();
  map.put("02","zhangsan2");
  map.put("03","zhangsan3");
  map.put("01","zhangsan1");
  map.put("04","zhangsan4");
    Set<String> keySet = map.keySet();
  //有了Set集合。就可以获取其迭代器。
  Iterator<String> it = keySet.iterator();

  while(it.hasNext())
  {
   String key = it.next();
   //有了键可以通过map集合的get方法获取其对应的值。
   String value  = map.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集合中的元素。   

public static void main(String[] args) {Map<String,String> map = new HashMap<String,String>();map.put("02","zhangsan2");map.put("03","zhangsan3");map.put("01","zhangsan1");map.put("04","zhangsan4");Set<Map.Entry<String,String>> entrySet = map.entrySet();//返回一个Set集合Iterator<Map.Entry<String,String>> it = entrySet.iterator();//得到Set集合迭代器while(it.hasNext()){Map.Entry<String,String> me = it.next();//得带May关系String key = me.getKey();//通过关系得到KeyString value = me.getValue();//通过关系得到ValueSystem.out.println(key+":"+value);}}

Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。

interface Map{public static interface Entry{public abstract Object getKey();public abstract Object getValue();}}class HashMap implements Map{class Hahs implements Map.Entry{public  Object getKey(){}public  Object getValue(){}}}

 

Map扩展：
HashMap<String,List<Student>> czbk = new HashMap<String,List<Student>>();
让值为一个集合，可以分出层次。

使用TreeMap进行排序：相似TreeSet
因为数据是以键值对形式存在的。
所以要使用可以排序的Map集合。TreeMap。
TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator());
//new StuNameComparator()为比较器

第十七天
集合框架中的工具类：
集合框架的工具类。
Collections:集合框架的工具类。里面定义的都是静态方法。
Collections和Collection有什么区别？
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
  它有两个常用的子接口，
  List：对元素都有定义索引。有序的。可以重复元素。
  Set：不可以重复元素。无序。
Collections是集合框架中的一个工具类。该类中的方法都是静态的
  提供的方法中有可以对list集合进行排序，二分查找等方法。
  通常常用的集合都是线程不安全的。因为要提高效率。
  如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。
static <T> void  sort(List<T> list, Comparator<? super T> c) //给List集合排序的方法             
          根据指定比较器产生的顺序对指定列表进行排序。

static <T> void fill(List<? super T> list, T obj)//替换List集合中元素为 T obj
          使用指定元素替换指定列表中的所有元素。
static void reverse(List<?> list)
          反转指定列表中元素的顺序
static <T> Comparator<T> reverseOrder()
      返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
         返回一个比较器，它强行逆转指定比较器的顺序。
  
Arrays:用于操作数组的工具类。里面都是静态方法。
asList:将数组变成list集合，即返回一个List集合
把数组变成list集合有什么好处？
  可以使用集合的思想和方法来操作数组中的元素。
  注意：将数组变成集合，不可以使用集合的增删方法。
  因为数组的长度是固定。
  contains。
  get
  indexOf()
  subList();
  如果你增删。那么会反生UnsupportedOperationException,

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

集合变数组。
Collection接口中的toArray方法。
1,指定类型的数组到底要定义多长呢？
  当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
  当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。
  所以创建一个刚刚好的数组最优。
2,为什么要将集合变数组？
  为了限定对元素的操作。不需要进行增删了。

import java.util.*;class  CollectionToArray{public static void main(String[] args) {ArrayList<String> al = new ArrayList<String>();al.add("abc1");al.add("abc2");al.add("abc3");String[] arr = al.toArray(new String[al.size()]);//创建一个刚刚好的数组最优System.out.println(Arrays.toString(arr));}}

 

高级for循环：
格式：
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{
 
}
对集合进行遍历。
 只能获取集合元素。但是不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

Set<Integer> keySet = hm.keySet();for(Integer i : keySet){System.out.println(i+"::"+hm.get(i));}for(Map.Entry<Integer,String> me : hm.entrySet()){System.out.println(me.getKey()+"------"+me.getValue());}

传统for和高级for有什么区别呢？

int[] arr = {3,5,1};for(int x=0; x<arr.length; x++){System.out.println(arr[x]);}for(int i : arr){System.out.println("i:"+i);}

 

高级for有一个局限性。必须有被遍历的目标。建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。

 

可变参数：
int[] arr = {3,4};
show(arr);
int[] arr1 = {2,3,4,5};
show(arr1);  
可变参数。
  其实就是上一种数组参数的简写形式。
  不用每一次都手动的建立数组对象。
  只要将要操作的元素作为参数传递即可。
  隐式将这些参数封装成了数组。
public static void show(int... arr)//向数组随便穿几个int型数据

public static void show(String str,int... arr)//这种可以。
public static void show(int... arr,String str)//不行
所以int... arr必须定义在后面

静态导入：
当方法不重名：
 导入前：
 Arrays.toString();
 导入后：
 import static  java.util.Arrays.*;
 toString();
当方法重名时，指定具备所属的对象或者类。
 toString()方法Object里面有，Arrays里面也有。
 导入前：
 Arrays.toString();
 导入后：
 import static  java.util.Arrays.*;
 Arrays.toString();

当类名不重名时：
import packa.*;
Demo A =new Demo();

当类名重名时，需要指定具体的包名。
import packa.*;
import packb.*;
packa.Demo A =new packa.Demo();
packb.Demo B =new packb.Demo();

System类：静态类
获取系统属性：

static Properties getProperties() ：确定当前的系统属性 Properties prop = System.getProperties();//获取所有属性信息。for(Object obj : prop.keySet()){String value = (String)prop.get(obj);System.out.println(obj+"::"+value);}//因为Properties是Hashtable的子类，也就是Map集合的一个子类对象。//那么可以通过map的方法取出该集合中的元素。//该集合中存储都是字符串。没有泛型定义。static String setProperty(String key, String value) ：设置指定键指示的系统属性。//如何在系统中自定义一些特有信息呢？System.setProperty("mykey","myvalue");static String getProperty(String key) ：获取指定键指示的系统属性 //获取指定属性信息。String value = System.getProperty("os.name");//操作系统名称,即KeySystem.out.println("value="+value);//可不可以在jvm启动时，动态加载一些属性信息呢？String v = System.getProperty("haha");System.out.println("v="+v);

DOS命令行：
  java -Dhaha=qqqq 类名

 

Runtime对象:单例设计模式运用
该类并没有提供构造函数。
说明不可以new对象。那么会直接想到该类中的方法都是静态的。
发现该类中还有非静态方法。
说明该类肯定会提供了方法获取本类对象。而且该方法是静态的，并返回值类型是本类类型。
由这个特点可以看出该类使用了单例设计模式完成。
该方式是static Runtime getRuntime();
Runtime r = Runtime.getRuntime();
r.exec("notepad.exe  SystemDemo.java");//使用记事本打开指定文件

Date类：

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);//打印出来的月是对的，不用+1.}}

 

Calendar 计算机底层的月是0-11月的因为Date里面方法太多过时了，即用Calendar的方法

 

import java.util.*;import java.text.*;class  CalendarDemo{public static void main(String[] args) {Calendar c = Calendar.getInstance();c.set(2013,4,12)//4即指5月份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);sop(c.get(Calendar.YEAR)+"年");//sop((c.get(Calendar.MONTH)+1)+"月");sop(mons[index]);sop(c.get(Calendar.DAY_OF_MONTH)+"日");//sop("星期"+c.get(Calendar.DAY_OF_WEEK));sop(weeks[index1]);}}

 

Math 工具类：
double d = Math.ceil(16.34);//ceil返回大于指定数据的最小整数。
double d1 = Math.floor(12.34);//floor返回小于指定数据的最大整数。
long l = Math.round(12.54);//四舍五入
Math.random()//0-1间的随机数
new Random.nextInt()//免去强转