java杂

快捷键

显示类的方法与字段：Alt+7
显示类的结构或结构图：Ctrl+H ； Ctrl+Alt+U
代码自动生成：Alt+Enter
代码补全：Ctrl+/ （更改后）

static

构造方法也是一个静态方法

抽象类和接口

抽象类

抽象类中的字段和方法都必须是抽象的，用于继承

抽象类外部类中不能包含static方法，但是在内部类中可以使用static方法

接口

接口用于调用implement

接口中不能使用final、static、defaults

在接口中的字段和方法都是 publicabstract ....

泛型

泛型就是为了解决在数据结构的集合中添加了不同类型的结构时，没法统一的处理数据。所以引入了泛型，能更好的处理数据。

List<String> list = new ArrayList<String>;

向量Vector

是一个动态数组，解决了数组固定长度不可改变的问题

  // initial size is 3, increment is 2
      Vector v = new Vector(3, 2);

 　　v.addElement(new Integer(1));
      v.addElement(new Integer(2));

Hashtable

Hashtable在哈希表中存储键/值对。当使用一个哈希表，要指定用作键的对象，以及要链接到该键的值。

然后，该键经过哈希处理，所得到的散列码被用作存储在该表中值的索引。

Object put(Object key, Object value)
将指定 key 映射到此哈希表中的指定 value。

Properties

Properties 继承于 Hashtable.表示一个持久的属性集.属性列表中每个键及其对应值都是一个字符串。



Java 中的 Iterator 功能比较简单，并且只能单向移动：

(1) 使用方法 iterator() 要求容器返回一个 Iterator。第一次调用 Iterator 的 next() 方法时，它返回序列的第一个元素。注意：iterator() 方法是 java.lang.Iterable 接口,被 Collection 继承。
(2) 使用 next() 获得序列中的下一个元素。
(3) 使用 hasNext() 检查序列中是否还有元素。
(4) 使用 remove() 将迭代器新返回的元素删除。

每一个编译文件只能有一个public类、且这个类名要与文件名一致。

多态：父类引用指向子类对象。该引用的方法取决于左边的引用类型。

类型转换：
- 　　转换成int类型： int i = Integer.parseInt("123");
- 　　转换成boolean类型： boolean b = Boolean.parseBoolean("true");
- 转换成String类型： String s = String.valueOf(123);
char[]和String之间的转换
- 　 String转换成char[]： char[] cs = "Hello".toCharArray();
- char[]转换成String： String s = new String(cs);　　
逻辑与（ & ）和短路（ && ）与的区别
- 短路与和短路或采用短路的方式。从左到右计算，如果只通过运算符左边的操作数就能够确定该逻辑表达式的值，则不会继续计算运算符右边的操作数，提高效率。
float类型赋值时需要添加后缀F/f
浮点类型float，double的数据不适合在不容许舍入误差的金融计算领域。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。
控制语句分为三类：顺序、选择和循环。
  “顺序结构”代表“先执行a，再执行b”的逻辑。比如，先找个女朋友，再给女朋友打电话；先订婚，再结婚；

  “选择结构”代表“如果…，则…”的逻辑。比如，如果女朋友来电，则迅速接电话；如果看到红灯，则停车；

  “循环结构”代表“如果…，则再继续…”的逻辑。比如，如果没打通女朋友电话，则再继续打一次；如果没找到喜欢的人，则再继续找。
1.从结构化程序设计角度出发，程序有三种结构：顺序结构、选择结构和循环结构
　　2.选择结构

　（1）if单选择结构 if-else双选择结构 if-else if-else多选择结构

　（2）switch多选择结构

　　3.多选择结构与switch的关系：当布尔表达式是等值判断的情况，可使用多重选择结构或switch结构，如果布尔表达式区间判断的情况，则只能使用多重选择结构

　　（1）循环结构

　　（2）当型：while与for

　　（3）直到型:do-while

　　4.while与do-while的区别，在布尔表达式的值为false时while的循环体一次也不执行，而do-while至少执行一次
   递归结构包括两个部分：
  1.定义递归头。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。

  2.递归体。解答：什么时候需要调用自身方法。

包装类

public class demo {
    public static void main(String[] args) {
        //新建包装类
        Integer int1 = new Integer(19);
        Integer int2 = Integer.valueOf(1);
        //包装类转基本类
        int int3  = int2.intValue();
        //基本类转包装类
        Integer int4 = Integer.valueOf(int3);
        //字符串转包装类
        Integer int5 = Integer.parseInt("123");
        //包装类转字符串
        String int6 = Integer.toString(int5);
        //包装类常用的字段
        System.out.println(Integer.MAX_VALUE  + "  "  + Integer.MIN_VALUE);

    }
}

自动装箱/拆箱（问题：会出现空指针异常的问题，因为Integer可以为NULL）

        int int0 = 0;
        //自动装箱
        Integer int7 = 7;
        //自动拆箱
        int int8 = int7;
        System.out.println(int7);
        System.out.println(int8);

1. StringBuffer JDK1.0版本提供的类，线程安全，做线程同步检查，效率较低
2. StringBuilder JDK1.5版本提供的类，线程不安全，不做线程同步检查，因此效率较高。建议采用该类。

        //新建
        StringBuffer sb = new StringBuffer("abc");
        //添加字符串到尾部
        sb.append("bcd");
        //删除从索引1到3的3-1位的数据
        sb.delete(1,3);
        //在索引为1的位置上插入数据字符串 IO
        sb.insert(1,"IO");

        //新建
        StringBuilder sbu = new StringBuilder("ABC");
        //在末端添加字符串
        sbu.append("def");
        //在索引为1的地方添加字符串
        sbu.insert(1,"3");
        //反转字符串
        System.out.println(sbu.reverse().toString());

Date时间类是用于获取当前时间的类。根据1970年1月1日开始记毫秒。
SimpleDateForm类是用于将Date类转换成指定格式的字符串，或者将字符串转换成指定的Date类。

 public static void main(String[] args) throws ParseException {
        // new出SimpleDateFormat对象
        SimpleDateFormat s1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        SimpleDateFormat s2 = new SimpleDateFormat("yyyy-MM-dd");
        // 将时间对象转换成字符串
        String daytime = s1.format(new Date());
        System.out.println(daytime);
        System.out.println(s2.format(new Date()));
        System.out.println(new SimpleDateFormat("hh:mm:ss").format(new Date()));
        // 将符合指定格式的字符串转成成时间对象.字符串格式需要和指定格式一致。
        String time = "2007-10-7";
        Date date = s2.parse(time);
        System.out.println("date1: " + date);
        time = "2007-10-7 20:15:30";
        date = s1.parse(time);
        System.out.println("date2: " + date);
    }

Calendar日历类是一个抽象类，为我们提供了关于日期计算的相关功能，比如：年、月、日、时、分、秒的展示和计算。
GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统。
注意月份的表示，一月是0，二月是1，以此类推，12月是11。因为大多数人习惯于使用单词而不是使用数字来表示月份，这样程序也许更易读，父类Calendar使用常量来表示月份：JANUARY、FEBRUARY等等。 星期几这里是：1-7.周日是1，周一是2，。。。周六是7

获取绝对路径的源目录：System.out.println(System.getProperty("user.dir"));

Collection接口的两个子接口是List、Set接口。

List是有序、可重复的容器。

ArrayList底层是用数组实现的存储。特点：查询效率高，增删效率低，线程不安全。我们一般使用它。
LinkedList底层用双向链表实现的存储。特点：查询效率低，增删效率高，线程不安全。
Vector底层是用数组实现的List，相关的方法都加了同步检查，因此“线程安全,效率低”。比如，indexOf方法就增加了synchronized同步标记。

1. 需要线程安全时，用Vector。

2. 不存在线程安全问题时，并且查找较多用ArrayList(一般使用它)。

3. 不存在线程安全问题时，增加或删除元素较多用LinkedList。

Map就是用来存储“键(key)-值(value) 对”的。 Map类中存储的“键值对”通过键来标识，所以“键对象”不能重复。
Map 接口的实现类有HashMap、TreeMap、HashTable、Properties等。

HashMap采用哈希算法实现，是Map接口最常用的实现类。由于底层采用了哈希表存储数据，我们要求键不能重复，如果发生重复，新的键值对会替换旧的键值对。 HashMap在查找、删除、修改方面都有非常高的效率。

1. HashMap: 线程不安全，效率高。允许key或value为null。

2. HashTable: 线程安全，效率低。不允许key或value为null。

public static void main(String[] args) {
        Map<Integer, String> m1 = new HashMap<Integer, String>();
        Map<Integer, String> m2 = new HashMap<Integer, String>();
        m1.put(1, "one");
        m1.put(2, "two");
        m1.put(3, "three");
        m2.put(1, "一");
        m2.put(2, "二");
        System.out.println(m1.size());
        System.out.println(m1.containsKey(1));
        System.out.println(m2.containsValue("two"));
        m1.put(3, "third"); //键重复了，则会替换旧的键值对
        Map<Integer, String> m3 = new HashMap<Integer, String>();
        m3.putAll(m1);
        m3.putAll(m2);
        System.out.println("m1:" + m1);
        System.out.println("m2:" + m2);
        System.out.println("m3:" + m3);
    }

IO流

IO流的经典写法如示例10-2所示。

【示例10-2】使用流读取文件内容(经典代码，一定要掌握)

import java.io.*;
public class TestIO2 {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("d:/a.txt"); // 内容是：abc
            StringBuilder sb = new StringBuilder();
            int temp = 0;
            //当temp等于-1时，表示已经到了文件结尾，停止读取
            while ((temp = fis.read()) != -1) {
                sb.append((char) temp);
            }
            System.out.println(sb);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                //这种写法，保证了即使遇到异常情况，也会关闭流对象。
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

流的细分

按流的方向分
- 　　输入流：由数据源流向程序。一般以InputStream、Reader结尾。
- 　　输出流：由程序流出目的地。一般以OutputStream、Writer结尾。

按处理的数据单元分类：

1. 字节流：以字节为单位获取数据，命名上以Stream结尾的流一般是字节流，如FileInputStream、FileOutputStream。

2. 字符流：以字符为单位获取数据，命名上以Reader/Writer结尾的流一般是字符流，如FileReader、FileWriter。

按处理对象不同分类：

1. 节点流：可以直接从数据源或目的地读写数据，如FileInputStream、FileReader、DataInputStream等。

2. 处理流：不直接连接到数据源或目的地，是”处理流的流”。通过对其他流的处理提高程序的性能，如BufferedInputStream、BufferedReader等。处理流也叫包装流。

IO流类的体系

1. InputStream/OutputStream

字节流的抽象类。

2. Reader/Writer

字符流的抽象类。

3. FileInputStream/FileOutputStream

节点流：以字节为单位直接操作“文件”。

4. ByteArrayInputStream/ByteArrayOutputStream

节点流：以字节为单位直接操作“字节数组对象”。

5. ObjectInputStream/ObjectOutputStream

处理流：以字节为单位直接操作“对象”。

6. DataInputStream/DataOutputStream

处理流：以字节为单位直接操作“基本数据类型与字符串类型”。

7. FileReader/FileWriter

节点流：以字符为单位直接操作“文本文件”(注意：只能读写文本文件)。

8. BufferedReader/BufferedWriter

处理流：将Reader/Writer对象进行包装，增加缓存功能，提高读写效率。

9. BufferedInputStream/BufferedOutputStream

处理流：将InputStream/OutputStream对象进行包装，增加缓存功能，提高读写效率。

10. InputStreamReader/OutputStreamWriter

处理流：将字节流对象转化成字符流对象。

11. PrintStream

处理流：将OutputStream进行包装，可以方便地输出字符，更加灵活。

1. 需要线程安全时，用Vector。 2. 不存在线程安全问题时，并且查找较多用ArrayList(一般使用它)。 3. 不存在线程安全问题时，增加或删除元素较多用LinkedList。

[1. Xūyào xiànchéng ānquán shí, yòng Vector. 2. Bù cúnzài xiànchéng ānquán wèntí shí, bìngqiě cházhǎo jiào duōyòng ArrayList(yībān shǐyòng tā). 3. Bù cúnzài xiànchéng ānquán wèntí shí, zēngjiā huò shānchú yuánsù jiào duōyòng LinkedList.]

1. need thread-safe, with Vector.
2. Thread safety is not a problem, and find more with ArrayList (generally use it).

3. thread safety problem does not exist, add or delete elements more with LinkedList.

经典代码，一定要掌握

[Jīngdiǎn dàimǎ, yīdìng yào zhǎngwò]

Classic code, we must master