首页 » java » 正文

重学java(三)

Calendar翻译为日历。

SimpleDateFormat是日期的格式化类。
format()格式化。
parse()解析。

java8中新添加的类的示例。

import static java.lang.System.*;
public class CalendarDate8 {
    public static void main(String args[]){
        LocalDateTime now = LocalDateTime.now();
        out.println(now);
        LocalDateTime now2=LocalDateTime.now(ZoneId.of("Europe/Paris"));
        out.println(now2);
        LocalDateTime d1=LocalDateTime.of(2013, 12,31,23,59,59);
        LocalDateTime d4=LocalDateTime.parse("2013-12-31T23:59:59");
        out.println(d4);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
        LocalDateTime d6=LocalDateTime.parse("2013/12/31 23:59:59",formatter);//按照formatter规则转成能用的
        out.println(formatter.format(d6));  //把能用的格式化
        out.println(d6.getYear());
        out.println(d6.getMonth());
        out.println(d6.getDayOfYear());
        out.println(d6.getDayOfMonth());
        out.println(d6.getDayOfWeek());
        out.println(d6.getHour());
        out.println(d6.getMinute());
        out.println(d6.getSecond());
        out.println(d6.getNano());
        LocalDateTime d7 = d6.minusDays(1);
        LocalDateTime d8 = d6.plusHours(1).plusMinutes(30);
        out.println(d7);
        out.println(d8);
    }
}

集合实际上是用一个对象来代表一组对象。

最基本的接口是Collection和Map接口。

Collection有Set、List、Queue三个主要子接口。

Set有HashSet和TreeSet两种、List有ArrayList、Vector、LinkedList、Stack,其中LinkedList还实现了Queue接口。

Queue有LinkedList、PriorityQueue和ArrayQueue。

Collection主要有以下几种方法:

public boolean add(Object):加入元素
public boolean remove(Object o):移除元素
public void clear():清除所有元素。
public boolean contains(Object o):判断是否包含
public int size():元素个数
public boolean isEmpty():判断是否为空
public Iterator iterator():得到迭代器

Set中可以有null。

Vector是线程安全的,ArrayList是线程不安全的,Vector是synchronized的。

List的主要方法:

public int indexOf(Object o):查找某个元素
public Object elementAt(int index):获取某个位置的元素
public Object set(int index, Object element):设置某个位置的元素
public void removeElementAt(int index):移除某个位置的元素
public void insertElementAt(Object obj, int index):在某个位置插入元素。

栈Stack是Vector的子类:
压栈:push() 弹栈:pop()
检查是否为空:empty()

LinkedList具有offer()入队和poll()出队两个方法。

Map在java里面应该从三方面来看,一是键的集合、二是值的集合、三是“键-值”的集合。三个部分分别由
public Set keySet();
public Collection values();
public Set entrySet()。

Map的接口重要实现有:HashMap和TreeMap,另外还有Hashtable(杂凑表)和——Properties(属性组),其中Properities是Hashtable的子类,键和值都只限于String类。

Hashtable键的每个元素都要求实现equals()和hashCode()方法。

Hashtable的方法:
public void put(Object key, Object value):放入
public Object get(Object key):检索一个值
public Object remove(Object key):移除一个元素
public Enumeration keys():得到键的枚举器。

import static java.lang.System.*;
public class CalendarDate8 {
    public static void main(String args[]){
        Map ht = new Hashtable();
        ht.put("one", new Integer(1));
        ht.put("two", new Integer(2));
        ht.put("three", new Integer(3));
        ht.put("four", new Integer(4));
        ht.put("five", new Integer(5));

        Enumeration em = ((Hashtable) ht).keys();
        while(em.hasMoreElements()){
            Object key = em.nextElement();
            Object value = ht.get(key);
            out.println(""+key+"="+value);
        }
    }
}

注意java是2个字节,使用的unicode,所以按照c++的字典序来想会出问题。

泛型举例:

Vector<String> v=new Vector<String>();  
v.addElement("one");  
String s=v.elementAt(0);  

泛型保证了类型相同。

泛型类的定义是在普通类的定义时,在类名后面加一个或多个类型参数,类型参数用尖括号括起来,如

class MyClass<T>{
    T getValue(){return ...;}
}

泛型方法也是加个类型参数,不过类型参数要写在返回值类型的前面(因为函数返回值类型可能就是参数类型的)

public <T> void myMethod(T t){
    ......;
}
调用
<Date>myMethod(new Date());  

等号后面的参数可以省略。

定义泛型时,可以对类型进行限定
1. 规定参数类型为某种类型的子类型
class TNode<T extends Person>{...}

  1. 通配符?表示
    public static void reverse(List<?> list)

  2. extends表示继承,super表示是某个类的父类
    public static <T extends Object & Comparable<?super T> T min(Collection<? extends T>coll)
    这里的&表示同时满足。

自动装包:基本类型自动转换成包装类。
自动拆包:包装类自动转换成基本类型。

所有的Collection都可以用Iterator来列举元素,Vector等类还可以用Enumeration来列举元素。

Iterator中还有remove用于移除元素,所以Iterator的功能更强,使用更方便。

Iterator有以下三个方法;
1. public boolean hasNext();
2. public Object next();
3. public remove(); //移除当前元素

对于List,可以通过listIterator来得到一个ListIterator接口,它具有双向检索的功能,ListIterator还具有
1. boolean hasPrevious();
2. Object previous()得到前面的元素
3. void add(Object o) 当前位置前面加一个元素
4. void set(Object o)替换当前的元素
5. int nextIndex() 下一个元素的索引
6. int previousIndex()前一个元素的索引

Vector类的elements()方法可以返回一个Enumeration接口,有
1. boolean hasMoreElements()
2. Object nextElement()

Enumeration是线程安全的。

增强for语句可以枚举集合。

map使用的一个典型:

import static java.lang.System.*;
public class CalendarDate8 {
    public static void main(String args[]){
        Map<String,String> map = new HashMap<String,String>();
        map.put("one", "1");
        map.put("two", "2");
        map.put("three", "3");
        map.put("four", "4");
        map.put("five", "5");
        map.put("five", "52");
        map.put("six", "4");

        out.println(map.get("three"));

        for(String key:map.keySet()){
            out.println(key+":"+map.get(key));
        }
        for(String value:map.values()){
            out.println(value);
        }
        for(Map.Entry<String,String> entry : map.entrySet()){
            out.println(entry.getKey()+":"+entry.getValue());
        }

        Iterator it = map.entrySet().iterator();  
        while(it.hasNext()){
            Map.Entry<String,String> entry = (Map.Entry<String,String>)it.next();  
            out.println(entry.getKey()+":"+entry.getValue());
        }
    }
}

Arrays.sort();
Arrays.binarySearch(T a[], (int fromIndex,) (int toIndex, )T key);

Collection的排序和查找:List为主
public static void sort(List list);
public static void sort(List list, Comparator c);
public static int binarySearch(List, Object key);
public static int binarySearch(List list, Object key, Comparator c);

java.util.Comparator有两个方法:
int compare(Object o1, Object o2);比较大小
int equals(Object obj):判断相等

如果是实现Comparable的话,方法是compareTo()

每个进程都有一段专门的内存区域,并以PCB(进程控制块)作为它存在的标志。

线程间可以共享相同的内存单元(包括代码和数据),并利用这些共享单元来实现数据交换、实时通信与必要的同步操作。

一个线程可以理解为三个部分的组合:
1. cpu:虚拟的CPU,专门用于执行该线程的任务。
2. Code:代码,即线程中要执行的指令。
3. Data:数据,线程中要处理的数据,在程序中表现为变量。

虚拟的CPU由Thread类来实现线程的概念;CPU所执行的代码,在构造Thread类时,传递给Thread类对象;处理的数据,在构造类时,传递给Thread类对象。

为了构造一个Thread对象,可以传递一个Runnable对象给它,这个对象就是线程所需要的代码和数据的封装,Runnable接口只有public void run();一个接口,这个接口也就是要执行的代码。

执行线程,是执行thread类的start()方法。

通过继承Thread类,覆盖run方法,。

import static java.lang.System.*;
public class Main {
    public static void main(String args[]){
        Thread t = new MyThread();
        t.start();
    }
}

class MyThread extends Thread{
    @Override
    public void run(){
        out.println("创建的线程");
    }
}

通过向线程类的构造方法传递一个实现了Runnable的对象,以其中的代码和数据来构造线程。

import static java.lang.System.*;
public class Main {
    public static void main(String args[]){
        MyTask myTask = new MyTask(100);
        Thread t = new Thread(myTask);
        t.start();
    }
}
class MyTask implements Runnable{
    private int n;
    public MyTask(int n){
        this.n=n;
    }
    @Override
    public void run(){
        for(int i=1; i<=n; i++){
            out.println(i);
            try{
                Thread.sleep(500);  //这里可能默认传了当前的线程对象给静态方法
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

试了一下,发现能直接调用run方法,但是最好不要这样。

发表评论