宠着长岛冰茶吗

JAVASE详解（下篇）

1. 字符串

1.1. 字符串概述
1.2. 字符串常量

1.2.1. 字符串常量之数据共享性（难点）
1.2.2. 字符串常量之不可变性

1.3. 字符串对象

1.3.1. 字符串的构造器

1.4. 字符串的方法

1.4.1. 字符串的判断方法
1.4.2. 字符串的获取功能

2. 可变字符串

2.1. String和StringBuffer的比较
2.2. StringBuffer是线程安全的
2.3. SringBuffer的构造器
2.4. StringBuffer的API

3. Random随机数产生类
4. 包装类

4.1. 类型转换
4.2. 自动装箱和拆箱
4.3. 自动装箱的原理

5. 日期
6. List

6.1. List的迭代器ListIterator
6.2. ArrayList
6.3. LinkedList
6.4. Vector
6.5. 泛型

6.5.1. 自定义的泛型

6.6. 增强的for循环

7. Set

7.1. HashSet
7.2. LinkedHashSet
7.3. TreeSet
7.4. 可变参数

8. Map

8.1. HashMap
8.2. TreeMap
8.3. HashTable
8.4. LinkedHashMap

9. 文件

9.1. 文件的构造器
9.2. 创建文件
9.3. 文件的删除
9.4. 文件的判断
9.5. 文件的获取功能
9.6. 目录的子文件获取
9.7. 递归

9.7.1.练习：递归查询文件夹的内部所有文件？
9.7.2. 练习：如何删除一个文件夹下的所有文件（不包括目录）？

10. IO流

10.1. 字符流
10.2. 案例

10.2.1. 文件的追加
10.2.2. 输出换行
10.2.3. Writer的五种写入的方法

10.3. 字节流

10.3.1. 字符流转向字节流的桥梁

10.4. Properties
10.5. 序列化流

10.5.1. ObjectOutputStream

10.6. 字符编码

11. 线程

11.1. 线程的创建方式

11.1.1. 继承Thread类来创建线程
11.1.2. 实现Runnable接口来创建线程

11.2. 线程的执行原理
11.3. 线程生命周期
11.4. 并发

11.4.1. 第一种同步处理
11.4.2. 第二种同步处理

11.5. Synchronized

11.5.1. Synchronized如果放在对象方法上
11.5.2. Synchronized如果在类方法上那么锁对象就是类的类对象

11.6. 休眠
11.7. 线程间的通信

11.7.1. 第一种实现方式：
11.7.2. 线程的第二种实现方式实现runnable

11.8. 线程的优先级
11.9. 加入线程
11.10. 让出线程
11.11. 守护线程
11.12. 死锁

1. 字符串

1.1. 字符串概述

字符串是引用数据类型，不是基本数据类型。

数据类型

基本数据类型

引用数据类型

数值型

字符型 (char)

布尔类型 (boolean)

整数类型 (byte, short, int, long)

浮点类型 (float, double)

类 (class)

接口 (interface)

数组 ([ ])

1.2. 字符串常量

1.2.1. 字符串常量之数据共享性（难点）

示例代码：

public class StringConstant {

    public static void main(String[] args) {
        String str = "hello";
        String str1 = "hello";
        System.out.println(str == str1);
    }
}

字符串的常量是存储在数据共享区中（jdk1.7之前是在方法区中，jdk1.8之后是在堆中），如果创建一个字符串的常量，首先会先在常量池里面去查找是否存在这个常量，如果存在就不创建直接指向，如果不存在那么就创建。
附：Java常量字符串String理解
JDK1.8关于运行时常量池, 字符串常量池的要点
内存结构：（jdk1.7之前）

内存结构：（jdk1.8之后）

1.2.2. 字符串常量之不可变性

字符串的常量是永远不可变的，如果对字符串拼接，实际上是新产生的字符串常量，不会在原有的字符串常量上变化。

1.3. 字符串对象

1.3.1. 字符串的构造器

public class StringDemo {

    public static void main(String[] args) {
        //  "" 第一种了解即可
        String s = new String();
        String str = "";
        System.out.println(s);

        byte[] bs = {97, 98, 99};
        //把字节作为ascii转换成字符连接到一起
        String s1 = new String(bs);
        System.out.println(s1);

        byte[] bs1 = {97, 98, 99, 100, 101};
        //参数1 目标数组，参数2 开始索引，参数3 截取的长度
        String s2 = new String(bs1, 1, 3);
        System.out.println(s2);

        char [] cs = {'h','e','l','l','o'};
        String s3 = new String(cs);
        System.out.println(s3);

        String s4 = new String(cs, 2, 2);
        System.out.println(s4);

        String s5 = "world";
        String s6 = new String(s5);
        System.out.println(s6);

    }
}

面试题：String str1 = new String(“abc”);创建了几个对象？
答：如果这行代码之前没有创建过abc的字符串的常量，就会创建两个，一个在堆中，一个在堆中的字符串常量池中。如果之前已经创建了字符串的常量abc，那么就只在堆中创建一个对象，字符串的常量对通过这个对象自动的查找而引用。

1.4. 字符串的方法

1.4.1. 字符串的判断方法

变量和类型	方法	描述
boolean	endsWith(String suffix)	测试此字符串是否以指定的后缀结尾。
boolean	equals(Object anObject)	将此字符串与指定的对象进行比较。
boolean	equalsIgnoreCase(String anotherString)	将此 String与另一个 String比较，忽略了大小写。
boolean	contains(CharSequence s)	当且仅当此字符串包含指定的char值序列时，才返回true。
boolean	startsWith(String prefix)	测试此字符串是否以指定的前缀开头。
boolean	isEmpty()	当且仅当 length() 为 0 ，返回 true 。

public class Demo {

    public static void main(String[] args) {
        String s = "helloworld";
        //判断字符串是否以某一个子字符串为结尾
        boolean ends = s.endsWith("world");
        System.out.println(ends);

        String s1 = "HelloWorld";
        //判断两个字符串的值是否相等，注意一下空指针
        boolean equals = s.equals(s1);
        System.out.println(equals);
        //判断两个字符串的值不考虑大小写是否相等，注意一下空指针
        boolean ignoreCase = s.equalsIgnoreCase(s1);
        System.out.println(ignoreCase);

        //判断字符串是否包含一个子字符串
        boolean contains = s.contains("owo");
        System.out.println(contains);

        boolean starts = s.startsWith("hello");
        System.out.println(starts);

        //判断字符串是否是空字符， 不推荐
        boolean empty = s.isEmpty();
        System.out.println(empty);

        //判断字符串是否是空串，推荐的用法
        boolean equals1 = "".equals(s);
        System.out.println(equals1);

    }
}

1.4.2. 字符串的获取功能

变量和类型	方法	描述
int	length()	返回此字符串的长度。
char	charAt(int index)	返回指定索引处的 char值。
int	indexOf(int ch)	返回指定字符第一次出现的字符串中的索引。
int	indexOf(String str)	返回指定子字符串第一次出现的字符串中的索引。
int	indexOf(String str, int fromIndex)	从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。
String	substring(int beginIndex)	返回一个字符串，该字符串是此字符串的子字符串。
String	substring(int beginIndex, int endIndex)	返回一个字符串，该字符串是此字符串的子字符串。

作业一：计算一个字符串中大写字母和小写字母还有数字的数量

public class Demo {

    public static void main(String[] args) {
        String s = "OLO2343AJFLJSDF56opias32jdfadfga";

        int numCount = 0;
        int upperCount = 0;
        int lowerCount = 0;
        
        //遍历这个字符串
        for (int i = 0; i < s.length(); i++) {
            //根据索引获得对应的字符
            char c = s.charAt(i);
            //转换成ascii
            int ascii = c;
            if(ascii >= 48 && ascii <= 57){
                numCount++;
            }
            if(ascii >= 65 && ascii <= 90){
                upperCount++;
            }
            if(ascii >= 97 && ascii <= 122){
                lowerCount++;
            }
        }
        
        System.out.println("数字："+numCount);
        System.out.println("大写："+upperCount);
        System.out.println("小写："+lowerCount);

    }
}

变量和类型	方法	描述
byte[]	getBytes()	使用平台的默认字符集将此 String编码为字节序列，将结果存储到新的字节数组中。
char[]	toCharArray()	将此字符串转换为新的字符数组。
static String	valueOf(boolean b)	返回 boolean参数的字符串表示形式。
static String	valueOf(char c)	返回 char参数的字符串表示形式。
static String	valueOf(char[] data)	返回 char数组参数的字符串表示形式。
String	toUpperCase()	使用默认语言环境的规则将此 String所有字符转换为大写。
String	toUpperCase(Locale locale)	使用给定 Locale的规则将此 String所有字符转换为大写。
String	concat(String str)	将指定的字符串连接到此字符串的末尾。

作业2：从控制台输入一段字符串，然后把首字母变成大写，其余变成小写

public class Demo {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        while (true){
            String line = s.nextLine();
            if("".equals(line)){
                System.out.println("输入的字符串不合法，请重新输入");
            }else{
                if ("-1".equals(line)){
                    break;
                }
                //   helloworld
                String firstLetter = line.substring(0, 1);
                //获得第一个字符后面的字符串
                String rest = line.substring(1);
                System.out.println("结果是："+firstLetter.toUpperCase()+rest.toLowerCase());
            }
        }
        System.out.println("程序结束");
    }
}

变量和类型	方法	描述
String[]	split(String regex)	将此字符串拆分为给定 regular expression的匹配项。
String	replace(char oldChar, char newChar)	返回字符串 newChar 替换字符串 oldChar后形成的新字符串。
String	replace(CharSequence target, CharSequence replacement)	将此字符串中与文字目标序列匹配的每个子字符串替换为指定的文字替换序列。
String	trim()	返回一个字符串，其值为此字符串，删除了所有前导和尾随空格，其中space被定义为其代码点小于或等于 ‘U+0020’ （空格字符）的任何字符。

需求：找出下面字符串中li的数量
"liasdflihsdhllihsdflihsdfiligsdfglikhsdfklilisdflio"

public class Demo {

    /**
     * 需求：找出下面字符串中li的数量
        "liasdflihsdhllihsdflihsdfiligsdfglikhsdfklilisdflio"
     */
    public static void main(String[] args) {
        String s = "liasdflihsdhllihsdflihsdfiligsdfglikhsdfklilisdflio";
        //定义一个计数器
        int count = 0;
        //获得li第一次出现的索引
        int index = s.indexOf("li");
        while (index != -1){
            //计数器累加
            count++;
            //找下一个li
            index = s.indexOf("li", index+2);
        }
        System.out.println("li的数量："+count);
    }
}

2. 可变字符串

2.1. String和StringBuffer的比较

String:

String str = “hello”;
str = str +”world”;

StringBuffer:

StringBuffer s = new StringBuffer("hello");
StringBuffer s1 = s.append("world");

2.2. StringBuffer是线程安全的

线程是程序运行的最小的单元。

StringBuffer s = new StringBuffer(“hell”);

A线程和B线程完全同时来操作这个可变字符串

线程的安全保证了数据的安全性，但随之带来的是性能的低下。

2.3. SringBuffer的构造器

StringBuffer s = new StringBuffer();
//获得可变字符串的容量
int capacity = s.capacity();
System.out.println(capacity);

&emsp可变字符串;默认预留了16个位置（容量）。

h	e	l	l	o	w	o	r	l	d	l	i	a	n	g	g

public class StringBufferDemo {

    public static void main(String[] args) {
        StringBuffer s = new StringBuffer();
        int length = s.length();
        System.out.println("可变字符串的长度："+length);
        //获得可变字符串的容量
        int capacity = s.capacity();
        System.out.println("可变字符串的容量"+capacity);

        s.append("helloworld");
        //获得可变字符串的容量
        capacity = s.capacity();
        System.out.println("可变字符串的容量"+capacity);
        s.append("liangge");
        //获得可变字符串的容量
        capacity = s.capacity();
        System.out.println("可变字符串的容量"+capacity);
        
        StringBuffer s1 = new StringBuffer("gege");
    }
}

2.4. StringBuffer的API

append:

public class StringBufferDemo {

    public static void main(String[] args) {
        StringBuffer s = new StringBuffer();
        /*s.append("tx");
        s.append(2.1f);
        s.append(3.4);
        s.append(new char[]{'a','b','c'});
        s.append(new String("mystring"));*/

        s.append("tx")
                .append(2.1f)
                .append(3.4)
                .append(new char[]{'a','b','c'})
                .append(new String("mystring"));

        System.out.println(s);

    }
}

insert:

public class StringBufferDemo {

    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("helloworld");
        //插入的时候一定要注意索引不要越界
        s.insert(3, true);
        System.out.println(s);

    }
}

删除:

public class StringBufferDemo {

    public static void main(String[] args) {
        StringBuffer s = new StringBuffer("helloworld");
        //删除指定索引处的字符串，不要越界啊
        s.deleteCharAt(5);
        System.out.println(s);
        StringBuffer s1 = new StringBuffer("helloworld");
        //删除开始索引到结束索引之间的字符串，包头不包尾，注意越界啊
        s1.delete(3,5);
        System.out.println(s1);
    }
}

3. Random随机数产生类

应用场景：
1. 验证码;
2. 彩票、抽奖;
3. 文件服务器···

public class RandomTest {

    public static void main(String[] args) {

        //创建一个随机数的对象
        Random r = new Random();
        for (int i = 0; i < 10; i++) {
            //获得一个 0~n(不包括n)     随机的整数
            int nextInt = r.nextInt(1000);
            System.out.println(nextInt);
        }
    }
}

4. 包装类

8中基本数据类型不是类，是有局限性的。jdk5以后为每一种基本数据类型都提供了其包装类。包装类就是给基本数据类型做增强的。

基本数据类型	byte	short	int	long	float	double	char	boolean
包装类	Byte	Short	Integer	Long	Float	Double	Character	Boolean

Integer的构造器:

public class Demo {

    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

        //创建一个Integer对象
        Integer integer = new Integer(10);
        System.out.println(integer);

        //创建一个以字符串为参数的构造器, 字符串不能是非数值类型或者越界int
        Integer integer1 = new Integer("100");
        System.out.println(integer1);

    }
}

4.1. 类型转换

int—>Integer

//创建一个Integer对象
Integer integer = new Integer(10);
System.out.println(integer);

Integer integer1 = Integer.valueOf(i);
System.out.println(integer);

Integer—>int

Integer integer = new Integer(10);
int i = integer.intValue();
System.out.println(i);

String—>Integer

Integer integer1 = new Integer("100");
System.out.println(integer1);

Integer integer2 = Integer.valueOf("200");
System.out.println(integer2);

Integer—>String

Integer integer = new Integer(200);
String s = integer.toString();
String s1 = integer+"";
String s2 = String.valueOf(integer);

String—>int

String s = "123";
//对字符串有要求，不能越界和非数值形式
int i = Integer.parseInt(s);
System.out.println(i+1);

int—>String

int j = 10;
String s1 = j+"";
String s2 = String.valueOf(j);

常用方法

public class Demo {

    public static void main(String[] args) {
        String s = Integer.toBinaryString(100);
        String s1 = Integer.toHexString(100);
        String s2 = Integer.toOctalString(100);

        System.out.println(s);
        System.out.println(s1);
        System.out.println(s2);
    }
}

Integer判断

public class Demo {

    public static void main(String[] args) {
        Integer i1 = new Integer(100);
        Integer i2 = new Integer(100);
        //Integer是对象，不能==比较值
        System.out.println(i1 == i2);
        int i = 100;
        int j = 100;
        System.out.println(i == j);

        //比较Integer的值
        System.out.println(i1.equals(i2));
        System.out.println(i1.intValue() == i2.intValue());
    }
}

Integer的默认值
在实战中默认值是有含义。

public class Person {

    private String name;

    /**
     int的默认值是0
     1.男，2.女
     Integer默认值是null
     1.男，2.女
     */
    private Integer gender;
}

项目中建议使用Integer

4.2. 自动装箱和拆箱

public class Demo {

    public static void main(String[] args) {
        //自动装箱，自动把int转换成一个Integer对象
        Integer i = 10;
        //自动拆箱把Integer对象自动的转换成int类型
        int i2 = new Integer(100);

        Long l1 = 200l;
        long l2 = new Long(300l);

        Double d = 3.1;
        double d1 = new Double(1.2);
    }
}

4.3. 自动装箱的原理

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

自动装箱在-128~127之间是走的缓存；
在缓存区间之外都是new Integer(int)。

0	1	2	3	···				···	256
-128	-127	-126	-125	···				···	127

public class Demo {

    public static void main(String[] args) {
        Integer i = 1000;
        Integer i1 = 1000;

        Integer i2 = -126;
        Integer i3 = -126;

        System.out.println(i == i1);
        System.out.println(i2 == i3);
    }
}

5. 日期

public class DateDemo {

    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d);

        Date d1 = new Date(System.currentTimeMillis() - 24*60*60*1000);
        System.out.println(d1);

        //获得一个指定的日期的毫秒数（1970年1月1日 0点）
        long time = d1.getTime();
        System.out.println(time);

        int year = d.getYear();
        System.out.println(year+1900);
        int month = d.getMonth();
        System.out.println(month+1);
        int day = d.getDate();
        System.out.println(day);
    }

    @Deprecated
    public static void method(){

    }
}

6. List

List是有序的集合，就像我们的数组一样。我们可以把list理解为是一个长度可变的数组，而且提供了丰富的api。List集合的底层就是数组。
附：Java集合List详解

0	1	2	3	4
劳斯莱斯	宾利	迈巴赫	奔驰	宝马

public static void main(String[] args) {

    //创建一个list的集合
    List list = new ArrayList();
    //向末尾添加元素
    list.add("吴用"); //0
    list.add("刘唐"); //1
    list.add("宋江"); //2

    System.out.println(list);
    //我们在1处的索引位置来插入元素，我们插入一个元素的话，该索引后面的元素都会向后移动一位
    list.add(1, "晁盖");
    System.out.println(list);

    //创建一个集合
    List list1 = new ArrayList();
    list1.add("阮小五");
    list1.add("阮小二");
    list1.add("阮小⑦");

    list.addAll(list1);
    System.out.println(list);
    
}

6.1. List的迭代器ListIterator

通过ListIterator的方式遍历:

ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()){
    //获得迭代的元素
    String str = (String) listIterator.next();
    if("刘唐".equals(str)){
        //我们不能在一边遍历的时候一边操作集合，这样会有多线程的并发问题
        //list.add("白胜");
        
        //迭代器给我们提供了一个add方法让我们避免并发问题，但是添加的时候本次遍历不生效
        listIterator.add("白胜");
    }
    System.out.println(str);

}
System.out.println(list);

可以使用for循环来动态的遍历List集合:

System.out.println("---------------分割线for循环遍历list-----------------------");
//int size = list.size();
//for循环对list的变量, 我们可以使用动态获得集合的长度的方式来遍历
for (int i = 0; i < list.size(); i++) {
    //根据索引来获得对应的元素
    String str  = (String) list.get(i);
    if("刘唐".equals(str)){
        list.add("阮小五");
    }
    System.out.println(str);
}

0	1	2	3	4
劳斯莱斯	宾利	迈巴赫	奔驰	宝马

List中的元素是可以重复的。

6.2. ArrayList

ArrayList的底层是数组的原理。

特点：
1. ArrayList中的元素可以重复；
2. ArrayList是有序的集合，长度不固定；
3. ArrayList不是线程安全的，但是效率高；
4. ArrayList在添加数据的时候初始的长度是10，后续会以5个长度来扩充集合的长度。
注意：
1. ArrayList不是线程安全的集合，适合不要求线程安全的需求来实现；
2. 好处是性能高；
3. 缺点是线程不安全，可能带来数据不准确；
4. 如果线程要是同步的话，性能就会变低。

6.3. LinkedList

LinkedList也不是线程安全的。LinkedList是链表为原理，添加修改删除的性能高。

栈、队列和链表的对比：
栈：先进后出

队列：先进先出

链表：储存了元素和前后的地址

6.4. Vector

Vector底层也是数组的原理。线程安全的。

public static void main(String[] args) {
    Vector v = new Vector();
    v.add("宋江");
    v.add("晁盖");
    v.add("刘唐");
    System.out.println(v);


    Object o = v.get(1);
    //Object o1 = v.elementAt(1);
    System.out.println(o);
    
    System.out.println("--------------分割线-----------------");

    for (int i = 0; i < v.size(); i++) {
        Object o1 = v.get(i);
        System.out.println(o1);
    }
    
    System.out.println("--------------分割线-----------------");

    Enumeration elements = v.elements();
    while(elements.hasMoreElements()){
        Object o1 = elements.nextElement();
        System.out.println(o1);
    }

}

6.5. 泛型

泛型就是在集合中指定存储的数据类型，而且只能存储这种类型，在List<类型>必须要指定， ArrayList<>可以指定也可以不指定。基本数据类型不能作为泛型。

public static void main(String[] args) {
    //定义一个集合里面指定只能存储一种数据类型
    List<String> list = new ArrayList<>();
}

public static void main(String[] args) {
    //定义一个集合里面指定只能存储一种数据类型
    List<String> list = new ArrayList<>();
    
    //调用集合
    list.add("亮亮");
    list.add("腻腻");
    list.add("腻腻1");
    list.add("腻腻2");
    list.add("腻腻3");

    //创建一个迭代器对象
    Iterator<String> iterator = list.iterator();
    while(iterator.hasNext()){
        //获得到String类型
        String next = iterator.next();
        System.out.println(next);
    }

}

6.5.1. 自定义的泛型

语法：class/interface 类名/接口名 {

}

T只是泛型的一个标准，使用什么字符都可以，但是都要大写，不要使用特殊字符，建议用T。

自定义泛型类：

public class GenericTest<T> {

    //定义一个泛型的属性
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

测试：

public static void main(String[] args) {
    GenericTest<String> gt = new GenericTest<>();

    gt.setT("哈哈");
    //获得对应的泛型的结果
    String t = gt.getT();

    //指定泛型是Integer类型
    GenericTest<Integer> gt1 = new GenericTest<>();
    gt1.setT(1);
    Integer t1 = gt1.getT();

    //指定泛型是Integer类型的数组
    GenericTest<Integer[]> gt2 = new GenericTest<>();
    gt2.setT(new Integer[]{1, 2, 4});
    Integer[] t2 = gt2.getT();

    //测试2个泛型
    GenericTest1<String, Integer> gtt1 = new GenericTest1<>("亮哥", 30);

    GenericTest1<String, Date> gtt2 = new GenericTest1<>("亮哥", new Date());

}

6.6. 增强的for循环

在jdk1.5以后出现了增强的for循环对数组、集合来做遍历。增强的for不支持并发，如果有并发的需求请使用普通的for循环。

语法：for(数据类型变量：集合变量){
///
}

数据类型是集合或者数组中的值的类型

public static void main(String[] args) {
    //定义一个数组
    String [] strs = {"晁盖","宋江","刘唐","吴用"};

    for(String str : strs){
        System.out.println(str);
    }

    System.out.println("-----------------------------");

    List<Integer> list = new ArrayList();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);

    for (Integer i : list){
        System.out.println(i);
    }
    
    System.out.println("-----------------------------");

    //这个增强的for不能支持并发
    /*for (Integer i : list){
        if(i.equals(2)){
            list.add(10);
        }
        System.out.println(i);
    }*/

    for (int i = 0; i < list.size(); i++) {
        //根据索引获得集合的元素
        Integer val = list.get(i);
        //如果某个元素是2就在这个集合里加入一个10
        if(val.equals(2)){
            list.add(10);
        }
        System.out.println(val);
    }

}

7. Set

7.1. HashSet

特点：
1. 元素唯一性
2. 无序性
3. 允许null存在一个
4. 不是线程安全的集合（效率高）

public static void main(String[] args) {

    /**
     * set是无序的
     * set的元素是不可重复的，如果重复了就会自动的去掉
     * set只能有一个null
     */
    Set<String> set = new HashSet<>();
    //给set添加元素
    set.add("董卓");
    set.add("张让");
    set.add("何进");
    set.add("李肃");
    set.add(null);
    System.out.println(set);
    
}

我们对set的唯一性深究一下（重点）：

如果对象的hash值和equals都相等那么就是重复的对象。

public static void main(String[] args) {

   //创建一个存储Person对象的集合
    Set<Person> set = new HashSet<>();
    set.add(new Person("孔明", 26));
    set.add(new Person("刘备", 28));
    set.add(new Person("关羽", 27));
    set.add(new Person("张飞", 25));
    set.add(new Person("张飞", 25));

    System.out.println(set);
}

7.2. LinkedHashSet

特点：
1. 元素唯一性
2. 有序的
3. 允许null存在一个
4. 不是线程安全（效率高）

LinkedHashSet和HashSet来对比就是多了一个顺序。应用的不多。

public static void main(String[] args) {
    Set<String> set = new LinkedHashSet<>();
    set.add("董卓");
    set.add("张让");
    set.add("何进");
    set.add("李肃");
    set.add(null);
    System.out.println(set);
}

7.3. TreeSet

类如果要实现比较的规则都会实现Comparable接口。

TreeSet的特点：
1. 元素唯一性
2. 可自定义排序的
3. 不允许null存在
4. 不是线程安全

String对CompareTo的实现:

String str =  "ab";
String str1 = "ab";
//字符串的比较规则是先按着第一个字符来比较，如果说一个字符串的第一个字符比另一个字符串的首字符大，那么前者就大
//如果是整数说明str大， 如果是负数str1大， 如果是0相等
int i = str.compareTo(str1);
System.out.println(i);

创建学生对象实现comparable接口:

public class Student implements Comparable<Student>{

    private String name;

    private int age;

    public 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 "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //做年龄的差
        int flag = this.age - o.age;
        if(flag == 0){
            flag = this.name.compareTo(o.name);
        }
        return flag;
    }
}

测试：

Student s = new Student("abc", 20);
Student s1 = new Student("abc", 20);
int i1 = s.compareTo(s1);
System.out.println(i1);

public static void main(String[] args) {

    Set<Student> set = new TreeSet<>();
    Student s = new Student("abc", 20);
    Student s2 = new Student("abe", 20);
    Student s1 = new Student("abd", 19);

    set.add(s);
    set.add(s1);
    set.add(s2);
    
    System.out.println(set);
}

7.4. 可变参数

语法：修饰符返回值类型方法名（数据类型…变量）{

}

public class DynamicParamDemo {

    public static void main(String[] args) {
        //int result = add(10,  10, 20, 50, 90);
        int result = add(new int[]{10, 20, 30});
        System.out.println(result);
    }
    
    //数据类型 ... 变量名 这是可变参数的定义方式
    //可以代表数组， 还可以代表单个数的传递
    //如果调用的时候我们发现了正好能匹配的方法就不会调用可变参数的方法，如果不存在这么一个正好调用的方法就会调用可变参数的方法
    public static int add(int... a){
        int total = 0;
        for (int i = 0; i < a.length ; i++) {
            total += a[i];
        }
        return total;
    }

    /*public static int add(int a, int b){
        return a + b;
    }*/
    
}

8. Map

List集合:

0	1	2	3	4
鲁智深	林冲	白胜	吴用	公孙胜

Set集合：

鲁智深	林冲	白胜	吴用	公孙胜

Map集合： Map是一个键值对的集合。

花和尚	豹子头	白日鼠	智多星	入云龙
鲁智深	林冲	白胜	吴用	公孙胜

我们如果想要从map中获得值，可以根据键来获得。
Map虽然是集合但是和Collection的集合体系不是同一个体系。

Map的映射的特点:
1. 一个映射不能包含重复的键；
2. 每个键最多只能映射到一个值；
3. 键只允许有一个空值；
4. 值可以有多个空值；
5. Map也是无序的；
6. Map ：K和V表示泛型，map的key和value可以是任何类型（不能是基本数据类型），实际项目中K一般都是字符串类型。

8.1. HashMap

如果大家能理解Set那么Map的key也就能理解了。

特点：
1. 一个映射不能包含重复的键；
2. 如果存在重复的key就会把之前的覆盖掉；
3. 其实键就是Set，元素唯一，只能有一个null，元素是无序的；

public static void main(String[] args) {
    //创建一个Map集合
    Map<String, String> map = new HashMap<>();
    //向集合总加元素
    map.put("白日鼠","白胜");
    map.put("豹子头","林冲");
    map.put("小诸葛","富安");

    //key只能有一个是null，值任意
    /*map.put(null, null);
    map.put("aaaa", null);*/
    //值是可以重复的
    //map.put("大诸葛","富安");

    //如果存在重复的key就会把之前的覆盖掉
    //map.put("小诸葛","高衙内");
    System.out.println(map);
    
}

8.2. TreeMap

该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法；

特点：
1. 可以按着key来做排序；
2. Key不能null，key不能重复，值可以有多个null；
3. 不是线程安全的。

public static void main(String[] args) {
    //创建一个Map集合
    Map<String, String> map = new TreeMap<>();
    //向集合总加元素
    map.put("b","白胜");
    map.put("a","林冲");
    map.put("e","富安");
    map.put("c","富安");

    System.out.println(map);

}

Person实现了comparable接口，我们的treemap可以根据key来做排序：

public static void main(String[] args) {
    //创建一个Map集合
    Map<Person, String> map = new TreeMap<>();
    //向集合总加元素
    map.put(new Person("白日鼠", 30),"白胜");
    map.put(new Person("豹子头", 28),"林冲");
    map.put(new Person("及时雨", 35),"宋江");
    
    System.out.println(map);
    
}

8.3. HashTable

特点：
1. HashTable是map的实现类；
2. 不允许任何null值和null键；
3. HashTable中的元素没有顺序（跟添加的顺序无关）；
4. HashTable是线程安全的。

public static void main(String[] args) {
    //创建一个Map集合
    Map<String, String> map = new Hashtable<>();
    //向集合总加元素
    map.put("b","白胜");
    map.put("a","林冲");
    map.put("e","富安");
    map.put("c",null);
    
    System.out.println(map);

}

8.4. LinkedHashMap

特点：
1. LinkedHashMap是map的实现类；
2. 允许多个null值和一个null键；
3. LinkedHashMap有顺序（添加的顺序）；
4. LinkedHashMap不是线程安全的。

public static void main(String[] args) {
    //创建一个Map集合
    Map<String, String> map = new LinkedHashMap<>();
    //向集合总加元素
    map.put("b","白胜");
    map.put("a","林冲");
    map.put("e","富安");
    map.put("c",null);
    
    System.out.println(map);
    
}

9. 文件

9.1. 文件的构造器

public class FileDemo {

    public static void main(String[] args) {
        //文件的构造器是用来创建文件对象的, 我们创建文件对象的时候要保证文件路径正确
        File file = new File("D:\\tx.txt");
        System.out.println(file.getName());


        File file1 = new File("D:\\aaa", "拓薪教育.txt");
        System.out.println(file1.getName());


        //java中的File类的对象可以代表目录，也可以代表文件
        File file2 = new File("D:\\aaa");
        System.out.println(file2.getName());

        //根据目录的文件对象创建一个文件
        File file3 = new File(file2, "拓薪教育.txt");
        System.out.println(file3.getName());
        
    }
}

9.2. 创建文件

public class FileDemo1 {

    public static void main(String[] args) throws IOException {
        File file = new File("D:\\aaa\\hello.txt");
        //创建一个文件
        boolean newFile = file.createNewFile();
        System.out.println(newFile);

    }
}

public class FileDemo2 {

    public static void main(String[] args) throws IOException {
        //创建一个目录的对象,创建的目录上一层的路径必须正确
        File file = new File("D:\\aaa\\bbb");
        boolean mkdir = file.mkdir();
        System.out.println(mkdir);

    }
}

public class FileDemo3 {

    public static void main(String[] args) throws IOException {
        //创建一个目录的对象,创建的目录上一层的路径必须正确
        File file = new File("D:\\aaa\\ccc\\hhh\\ggg");
        boolean mkdir = file.mkdirs();
        System.out.println(mkdir);

    }
}

9.3. 文件的删除

public class FileDemo4 {

    public static void main(String[] args) throws IOException {
        /*
        File file = new File("D:\\tx.txt");
        //程序删除不走回收站
        file.delete();
		*/
		
        //删除路径的最后一层, 只有空目录才能被删除
        File file1 = new File("D:\\aaa\\bbb");
        boolean delete = file1.delete();
        System.out.println(delete);

    }
}

9.4. 文件的判断

绝对路径是指目录下的绝对位置，直接到的目标位置。
相对路径就是指由这个文件所在的路径引起的跟其它文件(或文件夹)的路径关系。

public class FileDemo5 {

    public static void main(String[] args) throws IOException {

        File file = new File("D:\\tx.txt");
        //判断文件是否存在
        boolean exists = file.exists();
        System.out.println(exists);

        //判断这个文件对象是否是文件
        boolean isFile = file.isFile();
        System.out.println("判断一个文件对象是否是文件："+isFile);

        //判断这个文件对象是否是目录
        boolean isDir = file.isDirectory();
        System.out.println("判断一个文件对象是否是目录："+isDir);

        boolean absolute = file.isAbsolute();
        System.out.println("判断一个文件对象是否是绝对路径："+absolute);

        File file1 = new File("D:\\aaa\\hello.txt");
        //判断文件是否可读
        boolean b = file1.canRead();
        System.out.println("文件是否可读："+b);

        //判断文件是否可写
        boolean w = file1.canWrite();
        System.out.println("文件是否可写："+w);

        //判断文件是否是隐藏的
        boolean h = file1.isHidden();
        System.out.println("文件是否隐藏："+h);

    }
}

9.5. 文件的获取功能

public class FileDemo6 {

    public static void main(String[] args) throws IOException {

        File file = new File("D:\\tx.txt");
        //获得文件的绝对路径
        String absolutePath = file.getAbsolutePath();
        System.out.println("文件的绝对路径是："+absolutePath);

        //创建一个文件对象，用相对路径, 相对路径就是当前的项目的跟路径
        File file1 = new File("a.txt");
        //file1.createNewFile();
        String absolutePath1 = file1.getAbsolutePath();
        System.out.println("文件的绝对路径是："+absolutePath1);

        //获得的就是当前文件对象的路径
        String path = file1.getPath();
        System.out.println("文件的路径是："+path);

        //获得文件名
        String name = file1.getName();
        System.out.println("获得文件名："+name);

        //获得a.txt的大小
        long length = file1.length();
        System.out.println("文件的大小是："+length);

        //获得最后的修改时间
        long l = file1.lastModified();
        System.out.println("文件的最后修改时间："+l);
    }
}

9.6. 目录的子文件获取

public class FileDemo7 {

    public static void main(String[] args) throws IOException {

        //获得电脑磁盘的跟目录
        File[] files = File.listRoots();
        System.out.println(Arrays.toString(files));

        //获得一个目录下的子文件对象
        File file1 = new File("D:\\aaa");
        //获得D:\aaa下的子文件对象
        File[] files1 = file1.listFiles();
        for (File f : files1){
            System.out.println(f);
        }

        //获得子文件的名字
        String[] list = file1.list();
        System.out.println(Arrays.toString(list));

    }
}

9.7. 递归

求一个数的阶乘:

public class FileDemo8 {

    public static void main(String[] args) throws IOException {

        int result = fn(5);
        System.out.println(result);
    }

    /**
     * 5! = 5*4!
     * 4! = 4*3!
     * 3! = 3*2!
     * 2! = 2*1!
     * 1! = 1
     *
     * fn(num) = num * fn(num - 1);
     *
     */
     
    public static int fn(int num){
        int result = 1;
        if(num > 1)
            //方法的自身调用自身就是递归
            result = num * fn(num - 1);
        return result;
    }
}

9.7.1.练习：递归查询文件夹的内部所有文件？

public class FileDemo9 {

    //定义一个文件目录的层级
    static int level;

    public static void main(String[] args) throws IOException {
        //创建一个目录
        File file = new File("D:\\Program Files\\eclipse-jee-mars-1-win32-x86_64\\eclipse\\workspace\\demo1");
        parseFile(file);
    }

    public static void parseFile(File file){

        if(file == null || !file.exists()){
            return;
        }
        //给层级来加一
        level++;

        //获得文件对象的子文件对象列表
        File[] files = file.listFiles();
        //遍历这些子文件
        for(File f : files){
            //打印层级的缩进
            for (int i = 0; i < level; i++)
                System.out.print("\t");


            //打印文件
            System.out.println(f.getName());
            //判断这些子文件是否是目录
            if(f.isDirectory()){
                //递归的方式来遍历
                parseFile(f);
            }
        }
        //本层次遍历完毕把层级减回来
        level--;

    }
}

9.7.2. 练习：如何删除一个文件夹下的所有文件（不包括目录）？

public class FileDemo11 {

    //定义一个文件目录的层级
    static int level;

    public static void main(String[] args) throws IOException {
        //创建一个目录
        File file = new File("D:\\aaa");
        parseFile(file);
    }

    public static void parseFile(File file){

        if(file == null || !file.exists()){
            return;
        }

        //获得文件对象的子文件对象列表
        File[] files = file.listFiles();
        //遍历这些子文件
        for(File f : files){
            //判断这些子文件是否是目录
            if(f.isDirectory()){
                //递归的方式来遍历
                parseFile(f);
            }else {
                f.delete();
            }
        }
        //删除空文件夹
        file.delete();

    }
}

10. IO流

IO概述：
IO（Input/Output）:输入和输出，指的是某个设备或环境进行数据的输入或者输出。例如：键盘的输入，再比如显示器就是输出设备，输出图像。
对于java来说输入输出问题，java将它抽象成流对象来解决。
以游戏程序为中心读取文件就是输入，写入文件是输出。
流的分类:
IO流在java中从输入输出角度分类：
1. 输入流
2. 输出流
IO流在java中从数据的角度来分类：
1. 字符流
  文本，我们能读的懂的都可以认为是字符流。比如：文章，java文件等等
2. 字节流
  二进制的数据，这种数据一般用文本打开我们读不懂。比如，图片文件，mp3文件，等等。

10.1. 字符流

文本，我们能读的懂的都可以认为是字符流。比如：文章，java文件等等

输出流:
输入流:
字符流的类的命名的规则：
1. 如果是输出流就以Writer结尾；
2. 如果是输入流就以Reader结尾。

10.2. 案例

使用字符流向一个文件输入helloworld。

步骤：
1.创建文件
2.创建输出流对象
3.把流指向指定的文件
4.释放资源

public class IOTest {

    public static void main(String[] args) {

        //创建一个文件
        File file = new File("test.txt");
        Writer writer = null;

        try {
            //IO流是需要关闭的，如果不这样设计就会不能关闭资源
            writer = new FileWriter(file);
            writer.write("HelloWorld");


        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //判断writer不是空防止空指针异常
            if(writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

10.2.1. 文件的追加

public class IOTest4 {

    public static void main(String[] args) {

        Writer writer = null;

        try {
            //IO流是需要关闭的，如果不这样设计就会不能关闭资源
            //writer = new FileWriter("test1.txt", true);
            writer = new FileWriter(new File("test1.txt"), true);
            writer.write("liangliang");

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //判断writer不是空防止空指针异常
            if(writer != null) {
                try {
                    //在关闭前会做flush的事情
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

10.2.2. 输出换行

把文本写入文件中，\n代表换行，问题是不同的环境下换行的方式也不一样:
Windows: \r\n
Linux:\n
Mac:\r

public class IOTest5 {

    public static void main(String[] args) {

        //创建一个文件
        File file = new File("test.txt");
        Writer writer = null;

        try {
            //IO流是需要关闭的，如果不这样设计就会不能关闭资源
            writer = new FileWriter(file);
            for (int i = 0; i < 100; i++) {
                writer.write("HelloWorld\r\n");
                //每次写入10个helloworld的时候做一次flush
                if(i % 10 == 0){
                    writer.flush();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //判断writer不是空防止空指针异常
            if(writer != null) {
                try {
                    //在关闭前会做flush的事情
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

10.2.3. Writer的五种写入的方法

public class IOTest6 {

    public static void main(String[] args) {

        //创建一个文件
        File file = new File("test.txt");
        Writer writer = null;

        try {
            writer = new FileWriter(file);
            //定义一个数组
            char[] c = {'a','b','p','b','p'};
            /*writer.write(c);

            //把数组中的一部分写入文件
            writer.write(c, 2, 2);

            writer.write(97);
            */

            writer.write("helloworld", 2, 2);

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(writer != null) {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

10.3. 字节流

10.3.1. 字符流转向字节流的桥梁

public class ConverterDemo {

    public static void main(String[] args) {
        //创建字符流转换字节流的桥梁的对象
        OutputStreamWriter ow = null;

        try {
            //ow = new OutputStreamWriter(new FileOutputStream("b.txt"));
        	//字符流通向字节流的桥梁可以指定存储的编码
            ow = new OutputStreamWriter(new FileOutputStream("b.txt"),"GBK");
            ow.write("中");
            ow.flush();

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                if(ow != null){
                    ow.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

10.4. Properties

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

特点：
1. 继承于Hashtable，是线程安全的键值对存储结构
2. Properties 可保存在流中或从流中加载
3. 只能保存字符串的键值对。

public class PropTest6 {


    public static void main(String[] args) {

        //创建一个Properties对象
        Properties prop = new Properties();


        InputStream in = null;
        try {
            //in = new FileReader("src/names.properties");
             in = PropTest6.class.getClassLoader().getResourceAsStream("names.properties");
             //从字节流中来加载数据到属性对象中
            prop.load(in);
            System.out.println(prop);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if(in != null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

10.5. 序列化流

对象输出流：
ObjectOutputStream 将 Java 对象写入 OutputStream。
对象输入流：
ObjectInputStream 对以前使用 ObjectOutputStream 写入的对象进行反序列化。

10.5.1. ObjectOutputStream

我们要序列化的对象需要实现序列化接口。

实现：

我们一般会提供一个 serialVersionUID
某个类序列化之后，如果类发生了，那么依然可以反序列化。
如果要是对多个对象来做序列化，一定要放在集合中。

10.6. 字符编码

存储:
在计算机中存储字符都是存储的字符所对应的数值以二进制的形式表示。
展示：
去相关的编码表中去查找该值（存储的值）所对应的字符。

用什么编码，就要用什么解码。

11. 线程

11.1. 线程的创建方式

11.1.1. 继承Thread类来创建线程

子类要重写run方法:

public class MyThread extends Thread {

    private String name;

    public MyThread(String name){
        this.name = name;
    }

    /**
     * 这就是线程执行的逻辑体
     */
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(name+"下载了"+i+"%");
        }
    }
}

测试代码：

public class ThreadTest {

    public static void main(String[] args) {
        //创建一个线程的对象
        MyThread mt = new MyThread("肖申克的救赎");
        //启动一个线程
        mt.start();

        //创建一个线程的对象
        MyThread mt1 = new MyThread("当幸福来敲门");
        //启动一个线程
        mt1.start();

        //System.out.println("方法结束");

    }
}

11.1.2. 实现Runnable接口来创建线程

示例代码:

public class DownLoad implements Runnable {

    private String name;

    public DownLoad(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(name+"下载了"+i+"%");
        }
    }
}

测试代码：

public class ThreadTest {

    public static void main(String[] args) {
        //创建线程对象
        Thread t = new Thread(new DownLoad("肖申克的救赎"));
        Thread t1 = new Thread(new DownLoad("当幸福来敲门"));
        t.start();
        t1.start();
    }
}

11.2. 线程的执行原理

线程的并发执行通过多个线程不断的切换CPU的资源，这个速度非常快，我们感知不到，我们能感知到的就是三个线程在并发的执行。

11.3. 线程生命周期

新建: 线程被new出来；
准备就绪：线程具有执行的资格，即线程调用了start()，没有执行的权利；
运行：具备执行的资格和具备执行的权利；
阻塞：没有执行的资格和执行权利；
销毁: 线程的对象变成垃圾，释放资源。

11.4. 并发

互联网的项目中存在着大量的并发的案例，如卖火车票，电商网站。

范例： 火车站有100张票，4个窗口同时买票。
分析： 4个窗口是4个线程同时在运行，100票是4个线程的共享资源。

语法：synchronized(锁对象){
//操作共享资源的代码
}

同步代码加在什么地方？
1. 代码被多个线程访问
2. 代码中有共享的数据
3. 共享数据被多条语句操作。

11.4.1. 第一种同步处理

public class SaleTicketThread extends Thread {

    private String name;

    /**
     * 定义共享的数据100张票
     */
    static int tickets = 100;

    //创建一个锁对象，这个对象是多个线程对象共享的数据
    static Object obj = new Object();

    public SaleTicketThread(String name) {
        this.name = name;
    }

    @Override
    public void run() {

        //卖票是持续的
        while (true){

            synchronized (obj){
                if(tickets > 0){
                    System.out.println(name+"卖出座位是"+(tickets--)+"号");
                }else{
                    break;
                }
            }

            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        System.out.println(name+"卖票结束");
    }
}

测试代码：

public class ThreadTest {

    public static void main(String[] args) {
        SaleTicketThread t1 = new SaleTicketThread("窗口1");
        SaleTicketThread t2 = new SaleTicketThread("窗口2");
        SaleTicketThread t3 = new SaleTicketThread("窗口3");
        SaleTicketThread t4 = new SaleTicketThread("窗口4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

11.4.2. 第二种同步处理

public class SaleTicket implements Runnable {
    /**
     * 多个线程共享的100张票
     */
    int tickets = 100;

    //创建一个锁对象，这个对象是多个线程对象共享的数据
    Object obj = new Object();

    @Override
    public void run() {
        //卖票是持续的
        while (true){
            synchronized (obj){
                if(tickets > 0){
                    System.out.println(Thread.currentThread().getName()+"卖出座位是"+(tickets--)+"号");
                }else{
                    break;
                }
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        System.out.println(Thread.currentThread().getName()+"卖票结束");
    }

}

测试代码：

public class ThreadTest {

    public static void main(String[] args) {
        //创建一个卖票的对象
        SaleTicket st = new SaleTicket();

        Thread t1 = new Thread(st, "窗口1");
        Thread t2 = new Thread(st, "窗口2");
        Thread t3 = new Thread(st, "窗口3");
        Thread t4 = new Thread(st, "窗口4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();

    }
}

11.5. Synchronized

11.5.1. Synchronized如果放在对象方法上

public class SaleTicket implements Runnable {
    /**
     * 多个线程共享的100张票
     */
    int tickets = 100;

    //创建一个锁对象，这个对象是多个线程对象共享的数据
    Object obj = new Object();

    @Override
    public void run() {
        //卖票是持续的
        while (true){
            if(saleTickets()){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        System.out.println(Thread.currentThread().getName()+"卖票结束");
    }


    /*public boolean saleTickets(){
        synchronized (obj){
            boolean isFinish = false;
            if(tickets > 0){
                System.out.println(Thread.currentThread().getName()+"卖出座位是"+(tickets--)+"号");
            }else{
                isFinish = true;
            }
            return isFinish;
        }
    }*/

    /**
     *
     * @return     如果一个对象方法上有synchronized的话那么锁的对象就是this
     */
    public synchronized boolean saleTickets(){
        //synchronized (obj){
        boolean isFinish = false;
        if(tickets > 0){
            System.out.println(Thread.currentThread().getName()+"卖出座位是"+(tickets--)+"号");
        }else{
            isFinish = true;
        }
        return isFinish;
        //}
    }
}

11.5.2. Synchronized如果在类方法上那么锁对象就是类的类对象

public class SaleTicketThread extends Thread {

    private String name;

    /**
     * 定义共享的数据100张票
     */
    static int tickets = 100;

    //创建一个锁对象，这个对象是多个线程对象共享的数据
    static Object obj = new Object();

    public SaleTicketThread(String name) {
        super(name);
        this.name = name;
    }

    @Override
    public void run() {

        //卖票是持续的
        while (true){
            if(saleTickets()){
                break;
            }
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        System.out.println(name+"卖票结束");
    }

    public static synchronized boolean saleTickets(){

        boolean isFinish = false;
        if(tickets > 0){
            System.out.println(Thread.currentThread().getName()+"卖出座位是"+(tickets--)+"号");
        }else{
            isFinish = true;
        }
        return isFinish;

    }
}

测试代码：

public class ThreadTest {

    public static void main(String[] args) {
        SaleTicketThread t1 = new SaleTicketThread("窗口1");
        SaleTicketThread t2 = new SaleTicketThread("窗口2");
        SaleTicketThread t3 = new SaleTicketThread("窗口3");
        SaleTicketThread t4 = new SaleTicketThread("窗口4");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

11.6. 休眠

在做服务器端的程序的时候都需要给一个休眠的时间，在没有 synchronized 代码块里面会让出cpu的资源。

public static void main(String[] args) {
    while(true){
        System.out.println(new Date());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

休眠在同步代码块内不会让出cpu：

synchronized (ojb){
    try {

        //我们休眠如果在synchronized内部就不会让出cpu的资源
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

11.7. 线程间的通信

生产者生成水果，如果水果没有被买走那么就不生产处于等待状态，如果水果被消费者买走这时候消费者会通知生产者告诉他我们已经把水果买走了请生产，消费者同理，如果水果已经生产出来那么就买走，买走之后再通知生产者水果已经没了请生产。

注意：
1.线程间的通信共享数据一定要有同步代码块synchronized；
2.一定要有wait和notify，而且二者一定是成对出现；
3.生产者和消费者的线程实现一定是在while（true）里面。

11.7.1. 第一种实现方式：

水果篮子：

public class Basket {

    private boolean isEmpty;

    public boolean isEmpty() {
        return isEmpty;
    }

    public void setEmpty(boolean empty) {
        isEmpty = empty;
    }
    
}

生产者：

public class Producer extends Thread {

    private Basket basket;

    public Producer(Basket basket){
        super();
        this.basket = basket;
    }

    @Override
    public void run() {

        while(true){
            //定义一个同步代码块
            synchronized (basket){
                try {
                    if(!basket.isEmpty()){
                        //线程等待的状态
                        basket.wait();
                    }
                    System.out.println("生成水果");
                    basket.setEmpty(false);
                    //通知在这个共享对象上等待的线程
                    basket.notify();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {

            }

        }
    }
}

消费者：

package cn.tx.demo8;

public class Consumer extends Thread{

    private Basket basket;

    public Consumer(Basket basket){
        super();
        this.basket = basket;
    }

    @Override
    public void run() {

        while(true){
            //定义一个同步代码块
            synchronized (basket){
                try {
                    if(basket.isEmpty()){
                        //线程等待的状态
                        basket.wait();
                    }
                    System.out.println("消费水果");
                    basket.setEmpty(true);
                        //通知在这个共享对象上等待的线程
                    basket.notify();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

        }
    }
}

11.7.2. 线程的第二种实现方式实现runnable

水果篮子：

public class Basket {
    private boolean isEmpty;

    public boolean isEmpty() {
        return isEmpty;
    }

    public void setEmpty(boolean empty) {
        isEmpty = empty;
    }
}

生产者：

package cn.tx.demo9;

public class Producer implements Runnable {


    private Basket basket;

    public Producer(Basket basket){
        super();
        this.basket = basket;
    }

    @Override
    public void run() {

        while(true){
            //定义一个同步代码块
            synchronized (basket){
                try {
                    if(!basket.isEmpty()){
                        //线程等待的状态
                        basket.wait();
                    }
                    System.out.println("生成水果");
                    basket.setEmpty(false);
                    //通知在这个共享对象上等待的线程
                    basket.notify();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {

            }

        }
    }
}

消费者：

package cn.tx.demo9;

public class Consumer implements Runnable{

    private Basket basket;

    public Consumer(Basket basket){
        super();
        this.basket = basket;
    }

    @Override
    public void run() {

        while(true){
            //定义一个同步代码块
            synchronized (basket){
                try {
                    if(basket.isEmpty()){
                        //线程等待的状态
                        basket.wait();
                    }
                    System.out.println("消费水果");
                    basket.setEmpty(true);
                        //通知在这个共享对象上等待的线程
                    basket.notify();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

        }
    }

}

测试：

public class Test {

    public static void main(String[] args) {
        Basket basket = new Basket();
        Producer producer = new Producer(basket);
        Consumer consumer = new Consumer(basket);

        Thread t = new Thread(producer);
        Thread t1 = new Thread(consumer);

        t.start();
        t1.start();
    }
}

11.8. 线程的优先级

我们可以通过public final void setPriority(int newPriority)来设置线程的优先级，但是优先级并不是绝对的，只是先对来说比其他的线程得到CPU的资源机会多一些。

public class ThreadTest {

    public static void main(String[] args) {
        //创建一个线程的对象
        MyThread mt = new MyThread("肖申克的救赎");
        //创建一个线程的对象
        MyThread mt1 = new MyThread("当幸福来敲门");

        mt.setPriority(Thread.MAX_PRIORITY);
        //启动一个线程
        mt.start();
        //启动一个线程
        mt1.start();

        //System.out.println("方法结束");

    }
}

11.9. 加入线程

join线程会抢先拿到CPU来执行线程，然后其他的线程再来执行。
加入线程必须要在先执行的线程的start下面来执行。

public class ThreadTest {

    public static void main(String[] args) {
        //创建一个线程的对象
        MyThread mt = new MyThread("肖申克的救赎");
        //创建一个线程的对象
        MyThread mt1 = new MyThread("当幸福来敲门");

        MyThread mt2 = new MyThread("魔戒1");

        mt.start();
        try {
            //加入线程必须要在先执行的线程的start下面来执行
            mt.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        mt1.start();

        mt2.start();
    }
}

11.10. 让出线程

当前的线程从运行阶段回到就绪阶段，目的是把CPU的资源让给其他的线程。

public class MyThread extends Thread {

    private String name;

    public MyThread(String name){
        this.name = name;
    }
    /**
     * 这就是线程执行的逻辑体
     */
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            System.out.println(name+"下载了"+i+"%");
            //让出线程
            Thread.yield();
        }
    }
}

11.11. 守护线程

守护线程会随着主线程的结束而结束。

public class ThreadTest {

    public static void main(String[] args) {
        //创建一个线程的对象
        MyThread mt = new MyThread("肖申克的救赎");
        //设置守护线程
        mt.setDaemon(true);
        mt.start();
        System.out.println("主线程结束");
    }
}

11.12. 死锁

在做线程开发的时候要避免出现死锁。
死锁程序:

public class DeadLockThread extends Thread {

    int flag;

    @Override
    public void run() {
        if(flag == 1){
            synchronized (Lock.lock1){
                System.out.println("进入锁1");
                synchronized (Lock.lock2){
                    System.out.println("进入锁1中的锁2");
                }
            }
        }else{
            synchronized (Lock.lock2){
                System.out.println("进入锁2");
                synchronized (Lock.lock1){
                    System.out.println("进入锁2中的锁1");
                }
            }
        }
    }
}

测试：

public class DeadLockTest {

    public static void main(String[] args) {
        DeadLockThread dt = new DeadLockThread();
        dt.flag = 1;
        DeadLockThread dt1 = new DeadLockThread();

        dt.start();
        dt1.start();

    }
}

你可能感兴趣的:(JAVA_SE)

“java（TM）Platform SE binary 已停止工作“的简单解决办法气派飞鹰编程语言与环境配置 java jdk
因为重装了java_SE,导致java_SE的环境变量有些变化,于是在使用命令行编译的时候,就出现了这种问题：我在网上找了好久没有合适的解决办法,最后自己找到了方法,记录在这里,希望能帮助到遇到同样问题的人。看一下自己的环境变量，win10的环境变量设置参考win10环境变量设置我看评论区有人把环境变量设置成用户变量了，应该设置成系统变量如果你发现C:\ProgramFiles\CommonFil
java能加se壳_Java_SE 方法详解哈特瑞姆 java能加se壳
方法详解方法1.java方法是语句的集合,它们搭配在一起执行一个功能;2.方法是解决一类问题的步骤的有序组合;3.方法包含于类或对象中;4.方法在程序中被创建,在其他地方被引用;代码示例://类对象方法()System.out.println()//调用系统类(System),标准输出对象(out)的方法(println);//权限修饰符返回值类型方法名称([类型参数]),类型参数看是否需要,可不
JAVA_SE进阶day01面向对象高级 XMind及总结矜持的小男人 JAVA_SE进阶 java
1.继承1.1基本概述概念:所谓的继承,就是生活中的继承.比如"子承父业","儿子继承父亲的财产".在Java中指的是"子类继承父类的代码"格式:publicclass子类extends父类{}注意:1.Java只支持单继承,不支持多继承,但支持多层继承.2.继承必须是逻辑能讲得通的继承3.构造方法不能被继承1.2优缺点优点:1.提高了代码的复用性(少写代码了).2.提高了代码的维护性(修改起来更
java se两个数相除_JAVA_SE变量和运算符 JENNIFER LU java se两个数相除
java中的数据类型分为两大类：一、基本数据类型(4类8种)：①整型(byte,short,int[默认类型],long),他们之间取值范围不同②浮点型(float,double[默认类型]),他们之间取值范围不同③字符型(char)④布尔型(boolean)二、引用数据类型，从数组开始接触常见进制，字符，转义符：1.进制(二进制，八进制，十进制，十六进制)同一个块内，不能声明同名变量变量的作用域
JAVA_SE基础——编码规范&代码编写规则脚本叔叔 JAVA_SE JavaSE
这次我来给大家说明下编码规范&代码编写规则↓编码规范可以帮助程序员在编程时注意一些细节问题，提高程序的可读性，让程序员能够尽快地理解新的代码，并帮助大家编写出规范的利于维护的Java代码。Java命名规范：Java对变量、包、类的命名进行了规范，遵循Java命名规范，可以使程序更易阅读和理解，Java命名规范主要有以下几点：1.对常量的命名规范：常量名应使用大写，单词间用下画线隔开，并且能够见其名
Ubuntu 18.04 jdk，Eclipse安装和配置 Elon0 linux环境搭建
文章目录1.简单理解JAVA_SE、EE、ME三者的区别2.在Ubuntu18.04中安装OracleJavaJDK10：安装位置卸载：3.在Ubuntu中添加和删除PPA的软件源添加PPA源删除PPA源4.安装Eclipselinux下如何查询jdk的安装路径preference1.简单理解JAVA_SE、EE、ME三者的区别JavaSE(JavaPlatform,StandardEdition
JAVA_SE基础——67.System类脚本叔叔 JAVA_SE JavaSE
System类对大家都不陌生吧！以前经常需要打印结果时使用的都是“System.out.println()”语句，这句代码中就使用了System类。System类定义了一些与系统相关的属性和方法，它所提供的属性和方法都是静态的，所以，想要引用这些属性和方法，直接使用System类调用即可。System类的常用方法—staticvoidexit(intstatus)该方法用于终止当前正在运行的Jav
独到理解@Java概述 Malegod丶小飞 #Java概述
@[TOC](Java_SE总结)文章目录Java概述计算机语言发展史Java版本发展版本更新Java三大体系Java特性Java环境搭建Java编码规范Java概述计算机语言发展史在我们的生活中，信息技术无处不在，几乎覆盖了生活的方方面面。作为技术发展的核心，计算机技术日新月异，发展越来越快，已经成为我们生活中必不可缺的一部分。那么了解计算机语言发展历程，有助于我们更好的学习Java语言。计算机
JAVA_SE基础——25.面向对象练习 weixin_30739595
昨晚我写了篇面向对象的内存分析，今天我们来做个小练习。。需求：使用java描述一个车与修车厂两个事物，车具备的公共属性:轮子数、名字、颜色，还具备跑的功能行为。跑之前要检测轮子是否少于了4个，如果少于了4个，那么要送到修车厂修理，修车厂修理之后，车的轮子数要补回来4个。然后车就继续的跑起来。修车厂：具备公共属性：名字、地址、电话。公共的行为：修车。-------------------------
JAVA_SE基础——23.类的定义 weixin_30691871
黑马程序员入学blog...java面向对象的语言对象：真实存在的唯一的实物。比如：我家的狗，类：实际就是对某种类型事物的共性属性与行为的抽取。抽象的概念。。。比如说：车你知道我值的是哪辆车吗？我们从小的时候就不断的接触很多的对象，我们的大脑就会把这些具备相同属性与行为的事物进行分类。如果还不明白的话看下图：下面的对象具备着类的基本属性（轮子、排气管、颜色..）就可以称得上车了。类就如一张造汽车的
JAVA_SE基础——6.标识符&关键字脚本叔叔 JAVA_SE JavaSE
学会写helloworld之后，我们就开始来认识标识符&关键字一、标识符标识符是指可被用来为类、变量或方法等命名的字符序列，换言之，标识符就是用户自定义的名称来标识类、变量或方法等。更简单的说，标识符就是一个名字。标识符的选择并不是任意的，Java语言规定标识符由字母、数字、下划线和美元符号（$）组成，并且第一个字符不能是数字。例如以下都是合法的标识符：numuser3price$namebook
JAVA的自学笔记小杜的自学笔记 Java基础
JAVA_学习路线Java_SE学习Java_Web学习数据库前几天碰见才出去闯荡几年的老朋友，通过简单的聊几句，我的三观不知是否发生改变。喧嚣繁华的城市在逼近，我曾憧憬向往的自由却渐行渐远。准备回归校园了，学习这学期所有的课程，该把日志先放一段时间，想想后续的路途。愿学习中的朋友都养成高级的自律，享受孤独中的快乐。千万不要给自己铐上了枷锁，试看人生路途就如同游戏的多样化，喜欢一款就一直玩下去Ja
JAVA_SE ----- 基础知识总结-----关键字,标识符,注释,常量 foresight_2015
1:关键字(1)被Java语言赋予特定含义的单词(2)特点：全部小写。(3)注意事项：A:goto和const作为保留字存在。B:类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记2:标识符(1)就是给类，接口，方法，变量等起名字的字符序列(2)组成规则：A:英文大小写字母B:数字C:$和_(3)注意事项：A:不能以数字开头B:不能是java中的关键字C:区分大小写(4)常见的命名规
网络编程总结 foresight_2015 JAVA-SE JAVA-SE--网络编程
JAVA_SE—基础知识总结–网络编程##(1)网络编程：用Java语言实现计算机间数据的信息传递和资源共享##(2)网络编程模型##(3)网络编程的三要素###I:IP地址####IP地址的组成：网络号段+主机号段A类：第一号段为网络号段+后三段的主机号段一个网络号：256*256*256=16777216B类：前二号段为网络号段+后二段的主机号段一个网络号：256*256=65536C类：前三
JAVA_SE ----- 基础知识总结-----方法,数组 foresight_2015
1:方法(1)方法：就是完成特定功能的代码块。注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。(2)格式：修饰符返回值类型方法名(参数类型参数名1,参数类型参数名2...){方法体语句;return返回值;}修饰符：publicstatic,private,等返回值类型：就是功能结果的数据类型方法名：就是起了一个名字，方便我们调用该方法。参数类型：就是参数的数据类型参数名：就是变
JAVA_Se异常的学习总结 foresight_2015
_异常(异常的概述和分类)*A:异常的概述*异常就是Java程序在运行过程中出现的错误。*B:异常的分类*通过API查看Throwable*Error*服务器宕机,数据库崩溃等*ExceptionC:异常的继承体系*Throwable*Error*Exception*RuntimeException###19.02_异常(JVM默认是如何处理异常的)*A:JVM默认是如何处理异常的*main函数收
【JAVA_SE】IO流双椒叔叔 Java java
1、流的分类读取数据就是输入流，写入数据就是输出流。按照处理的数据单位分为字节流和字符流字节流：操作的数据单元是8位的字节。InputStream、OutputStream作为抽象基类。字符流：操作的数据单元是字符。以Writer、Reader作为抽象基类。注意：字节流可以处理所有数据文件，若处理的是纯文本数据，建议使用字符流。2、IO流中的三类数据源基于磁盘文件：FileInputStream、
跟我一起学JAVAEE吧——JAVA_SE篇——day03上课笔记(分支结构，循环结构，break和continue) Persist丶丶上课笔记 java javase switch
day03分支结构if-else（可以嵌套）if(判断语句){执行语句}if（判断语句）{执行语句}if(判断语句){执行语句}else{执行语句}前面的if只要满足条件就会执行，最后的else只要前一个if不满足条件就会执行if(判断语句){执行语句}elseif（判断语句）{执行语句elseif(判断语句){执行语句}else{执行语句}只要前面有一个条件被满足后面的所有的else语句就不会执
高效解决使用java命令时出现Error: A JNI error has occurred, please check your...以及配置环境变量和Powershell验证法源代码•宸嘿Java！
如上图显示，说明系统中存在多个java版本或者java和javac版本不一致这可以看出系统中存在多个java版本。我去我的java文件目录下查，发现有Java_SE和jdk…文件，之前我是用jre运行java的，但后来又下载了jdk版本，所以当我删掉jre的Java_SE文件之后，一切都正常了。我想说，不到万不得已，最好还是不要重装java，原本只需要几秒钟删文件的事变成花将近一小时重装配置软件，
【Java_SE】作业练习1105 eclipse_newlearner 作业及练习
1:集合的嵌套遍历需求：我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList。而我现在有多个ArrayList。也要用集合存储，怎么办呢?importjava.util.ArrayList;importjava.util.Collection;importjava.util.I
【Java_SE】作业练习1104 eclipse_newlearner 作业及练习
1.需求：请设计一个方法，可以实现获取任意范围内的随机数importjava.util.Random;importjava.util.Scanner;publicclassDemo1{publicstaticvoidmain(String[]args){Scannersc=newScanner(System.in);System.out.println("请设置上限：");intstart=sc.
【JAVA_SE】作业练习1029 eclipse_newlearner 作业及练习
1.有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？(使用递归去解决)publicclassDemo1{publicstaticvoidmain(String[]args){System.out.println(f(20));intsum=0;for(inti=1;iarr[mid]){min=mid+1;}e
【JAVA_SE】作业练习1021 eclipse_newlearner 作业及练习
1:教练和运动员案例乒乓球运动员和篮球运动员。乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都需要学习英语。请用所学知识：分析，这个案例中有哪些抽象类，哪些接口，哪些具体类//测试类publicclassDemo{publicstaticvoidmain(String[]args){GoAbroadPingpongAthletespa1=newGoAbroadPingpongAthlete
简单粗暴理解JAVA_SE 、EE、ME 三者的区别大可.com JAVA
JavaSE(JavaPlatform,StandardEdition)，应该先说这个，因为这个是标准版本。JavaEE(JavaPlatform，EnterpriseEdition)，java的企业版本JavaME(JavaPlatform，MicroEdition)，java的微型版本。JavaSE可以开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的Java应用程序。是EE，和ME的基础
【JAVA_SE】作业练习1016 eclipse_newlearner 作业及练习
【JAVA_SE】作业练习1016第一题：importjava.util.Arrays;/**1.定义一个工具类其中提供了对于整形数组和double类型数组的一些工具方法。方法分别有:1.求数组值的和.2.求数组中的最大值3.对数组进行升序排序.4.对数组进行倒序排序(也就是反转数组)工具类要求:a.私有化构造方法b.不希望被继承***/publicclassDemo1{publicstaticv
JAVA_SE线程实现两种方式实例 sinat_28387645
JAVA中线程的创建一般是有两种方法一种为继承Thread类并实现Run()方法另一种是实现Runnable接口建议使用接口方式创建线程，这种方式更加灵活Demo1：继承Thread类publicclassDemo_1{ publicstaticvoidmain(String[]args){ //TODO自动生成的方法存根 Dogh=newDog(); Catc=newCat(); newThr
JAVA_SE使用反射机制new实例简例 sinat_28387645 反射 Class 实例
先建立一个People类，包含两个构造方法packagein.xlc.net;publicclassPeople{privateStringname;privateintage;publicStringgetName(){System.out.println("GetName");returnname;}publicvoidsetName(Stringname){this.name=name;}p
JAVA_SE基础——62.String类的构造方法 ThesCript_j java String
下面我先列出初学者目前用到的构造方法String的构造方法： String() 创建一个空内容的字符串对象。 String(byte[]bytes) 使用一个字节数组构建一个字符串对象 String(byte[]bytes,intoffset,intlength) bytes: 要解码的数组 offset：指定从数组中那个索引值开始解码。 length：要解码多个元素。 String(cha
JAVA_SE基础——62.String类的构造方法 ThesCript_j java String
下面我先列出初学者目前用到的构造方法String的构造方法： String() 创建一个空内容的字符串对象。 String(byte[]bytes) 使用一个字节数组构建一个字符串对象 String(byte[]bytes,intoffset,intlength) bytes: 要解码的数组 offset：指定从数组中那个索引值开始解码。 length：要解码多个元素。 String(cha
JAVA_SE基础——61.字符串入门 ThesCript_j 字符串 equals JavaSE
publicclassDemo1{ publicstaticvoidmain(String[]args){ Stringstr1="hello"; Stringstr2="hello"; Stringstr3=newString("hello"); Stringstr4=newString("hello"); System.out.println("str1==str2?"+(str1==st
java Illegal overloaded getter method with ambiguous type for propert的解决 zwllxs java jdk
好久不来iteye,今天又来看看，哈哈,今天碰到在编码时，反射中会抛出 Illegal overloaded getter method with ambiguous type for propert这么个东东，从字面意思看，是反射在获取getter时迷惑了，然后回想起java在boolean值在生成getter时，分别有is和getter，也许我们的反射对象中就有is开头的方法迷惑了jdk，
IT人应当知道的10个行业小内幕 beijingjava 工作互联网
10. 虽然IT业的薪酬比其他很多行业要好，但有公司因此视你为其“佣人”。　　尽管IT人士的薪水没有互联网泡沫之前要好，但和其他行业人士比较，IT人的薪资还算好点。在接下的几十年中，科技在商业和社会发展中所占分量会一直增加，所以我们完全有理由相信，IT专业人才的需求量也不会减少。　　然而，正因为IT人士的薪水普遍较高，所以有些公司认为给了你这么多钱，就把你看成是公司的“佣人”，拥有你的支配
java 实现自定义链表 CrazyMizzz java 数据结构
1.链表结构链表是链式的结构 2.链表的组成链表是由头节点，中间节点和尾节点组成节点是由两个部分组成： 1.数据域 2.引用域 3.链表的实现 &nbs
web项目发布到服务器后图片过一会儿消失麦田的设计者 struts2 上传图片永久保存
作为一名学习了android和j2ee的程序员，我们必须要意识到，客服端和服务器端的交互是很有必要的，比如你用eclipse写了一个web工程，并且发布到了服务器（tomcat）上，这时你在webapps目录下看到了你发布的web工程，你可以打开电脑的浏览器输入http://localhost:8080/工程/路径访问里面的资源。但是，有时你会突然的发现之前用struts2上传的图片
CodeIgniter框架Cart类 name 不能设置中文的解决方法 IT独行者 CodeIgniter Cart 框架　
今天试用了一下CodeIgniter的Cart类时遇到了个小问题，发现当name的值为中文时，就写入不了session。在这里特别提醒一下。在CI手册里也有说明，如下： $data = array( 'id' => 'sku_123ABC', 'qty' => 1, '
linux回收站 _wy_ linux 回收站
今天一不小心在ubuntu下把一个文件移动到了回收站，我并不想删，手误了。我急忙到Nautilus下的回收站中准备恢复它，但是里面居然什么都没有。后来我发现这是由于我删文件的地方不在HOME所在的分区，而是在另一个独立的Linux分区下，这是我专门用于开发的分区。而我删除的东东在分区根目录下的.Trash-1000/file目录下，相关的删除信息（删除时间和文件所在
jquery回到页面顶端知了ing html jquery css
html代码： <h1 id="anchor">页面标题</h1> <div id="container">页面内容</div> <p><a href="#anchor" class="topLink">回到顶端</a><
B树、B-树、B+树、B*树矮蛋蛋 B树
原文地址： http://www.cnblogs.com/oldhorse/archive/2009/11/16/1604009.html B树即二叉搜索树： 1.所有非叶子结点至多拥有两个儿子（Left和Right）； &nb
数据库连接池 alafqq 数据库连接池
http://www.cnblogs.com/xdp-gacl/p/4002804.html @Anthor:孤傲苍狼数据库连接池用MySQLv5版本的数据库驱动没有问题，使用MySQLv6和Oracle的数据库驱动时候报如下错误： java.lang.ClassCastException: $Proxy0 cannot be cast to java.sql.Connec
java泛型百合不是茶 java泛型
泛型在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，任意化的缺点就是要实行强制转换，这种强制转换可能会带来不安全的隐患泛型的特点：消除强制转换确保类型安全向后兼容简单泛型的定义：泛型：就是在类中将其模糊化，在创建对象的时候再具体定义 class fan
javascript闭包[两个小测试例子] bijian1013 JavaScript JavaScript
一.程序一 <script> var name = "The Window"; var Object_a = { 　　name : "My Object", 　　getNameFunc : function(){ var that = this; 　　　　return function(){ 　　　　
探索JUnit4扩展：假设机制（Assumption） bijian1013 java Assumption JUnit 单元测试
一.假设机制（Assumption）概述理想情况下，写测试用例的开发人员可以明确的知道所有导致他们所写的测试用例不通过的地方，但是有的时候，这些导致测试用例不通过的地方并不是很容易的被发现，可能隐藏得很深，从而导致开发人员在写测试用例时很难预测到这些因素，而且往往这些因素并不是开发人员当初设计测试用例时真正目的，
【Gson四】范型POJO的反序列化 bit1129 POJO
在下面这个例子中，POJO(Data类)是一个范型类，在Tests中，指定范型类为PieceData，POJO初始化完成后，通过 String str = new Gson().toJson(data); 得到范型化的POJO序列化得到的JSON串，然后将这个JSON串反序列化为POJO import com.google.gson.Gson; import java.
【Spark八十五】Spark Streaming分析结果落地到MySQL bit1129 Stream
几点总结： 1. DStream.foreachRDD是一个Output Operation，类似于RDD的action，会触发Job的提交。DStream.foreachRDD是数据落地很常用的方法 2. 获取MySQL Connection的操作应该放在foreachRDD的参数（是一个RDD[T]=>Unit的函数类型)，这样，当foreachRDD方法在每个Worker上执行时，
NGINX + LUA实现复杂的控制 ronin47 nginx lua
安装lua_nginx_module 模块 lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty Centos和debian的安装就简单了。。这里说下freebsd的安装： fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz tar zxvf lua-5.1.4.tar.gz cd lua-5.1.4 ma
java-递归判断数组是否升序 bylijinnan java
public class IsAccendListRecursive { /*递归判断数组是否升序 * if a Integer array is ascending,return true * use recursion */ public static void main(String[] args){ IsAccendListRecursiv
Netty源码学习-DefaultChannelPipeline2 bylijinnan java netty
Netty3的API http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/ChannelPipeline.html 里面提到ChannelPipeline的一个“pitfall”：如果ChannelPipeline只有一个handler（假设为handlerA）且希望用另一handler（假设为handlerB）来
Java工具之JPS chinrui java
JPS使用熟悉Linux的朋友们都知道，Linux下有一个常用的命令叫做ps（Process Status)，是用来查看Linux环境下进程信息的。同样的，在Java Virtual Machine里面也提供了类似的工具供广大Java开发人员使用，它就是jps（Java Process Status)，它可以用来
window.print分页打印 ctrain window
function init() { var tt = document.getElementById("tt"); var childNodes = tt.childNodes[0].childNodes; var level = 0; for (var i = 0; i < childNodes.length; i++) {
安装hadoop时执行jps命令Error occurred during initialization of VM daizj jdk hadoop jps
在安装hadoop时，执行JPS出现下面错误 [slave16][email protected]:/tmp/hsperfdata_hdfs# jps Error occurred during initialization of VM java.lang.Error: Properties init: Could not determine current working
PHP开发大型项目的一点经验 dcj3sjt126com PHP 重构
一、变量最好是把所有的变量存储在一个数组中，这样在程序的开发中可以带来很多的方便，特别是当程序很大的时候。变量的命名就当适合自己的习惯，不管是用拼音还是英语，至少应当有一定的意义，以便适合记忆。变量的命名尽量规范化，不要与PHP中的关键字相冲突。二、函数 PHP自带了很多函数，这给我们程序的编写带来了很多的方便。当然，在大型程序中我们往往自己要定义许多个函数，几十
android笔记之--向网络发送GET/POST请求参数 dcj3sjt126com android
使用GET方法发送请求 private static boolean sendGETRequest (String path, Map<String, String> params) throws Exception{ //发送地http://192.168.100.91:8080/videoServi
linux复习笔记之bash shell (3) 通配符 eksliang linux 通配符 linux通配符
转载请出自出处： http://eksliang.iteye.com/blog/2104387 在bash的操作环境中有一个非常有用的功能，那就是通配符。下面列出一些常用的通配符，如下表所示符号意义 * 万用字符，代表0个到无穷个任意字符 ? 万用字符，代表一定有一个任意字符 [] 代表一定有一个在中括号内的字符。例如：[abcd]代表一定有一个字符，可能是a、b、c
Android关于短信加密 gqdy365 android
关于Android短信加密功能，我初步了解的如下（只在Android应用层试验）： 1、因为Android有短信收发接口，可以调用接口完成短信收发；发送过程：APP（基于短信应用修改）接受用户输入号码、内容——>APP对短信内容加密——>调用短信发送方法Sm
asp.net在网站根目录下创建文件夹 hvt .net C#hovertree asp.net Web Forms
假设要在asp.net网站的根目录下建立文件夹hovertree,C#代码如下： string m_keleyiFolderName = Server.MapPath("/hovertree"); if (Directory.Exists(m_keleyiFolderName)) { //文件夹已经存在 return; } else { try { D
一个合格的程序员应该读过哪些书 justjavac 程序员书籍
编者按：2008年8月4日，StackOverflow 网友 Bert F 发帖提问：哪本最具影响力的书，是每个程序员都应该读的？ “如果能时光倒流，回到过去，作为一个开发人员，你可以告诉自己在职业生涯初期应该读一本，你会选择哪本书呢？我希望这个书单列表内容丰富，可以涵盖很多东西。” 很多程序员响应，他们在推荐时也写下自己的评语。以前就有国内网友介绍这个程序员书单，不过都是推荐数
单实例实践跑龙套_az 单例
1、内部类 public class Singleton { private static class SingletonHolder { public static Singleton singleton = new Singleton(); } public Singleton getRes
PO VO BEAN 理解 q137681467 VO DTO po
PO：全称是 persistant object持久对象最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。 BO：全称是 business object:业务对象主要作用是把业务逻辑封装为一个对象。这个对
战胜惰性，暗自努力金笛子努力
偶然看到一句很贴近生活的话：“别人都在你看不到的地方暗自努力，在你看得到的地方，他们也和你一样显得吊儿郎当，和你一样会抱怨，而只有你自己相信这些都是真的，最后也只有你一人继续不思进取。”很多句子总在不经意中就会戳中一部分人的软肋，我想我们每个人的周围总是有那么些表现得“吊儿郎当”的存在，是否你就真的相信他们如此不思进取，而开始放松了对自己的要求随波逐流呢？我有个朋友是搞技术的，平时嘻嘻哈哈，以
NDK/JNI二维数组多维数组传递 wenzongliang 二维数组 jni NDK
多维数组和对象数组一样处理，例如二维数组里的每个元素还是一个数组用jArray表示，直到数组变为一维的，且里面元素为基本类型，去获得一维数组指针。给大家提供个例子。已经测试通过。 Java_cn_wzl_FiveChessView_checkWin( JNIEnv* env,jobject thiz,jobjectArray qizidata) { jint i,j; int s