weixin_45267979
weixin_45267979

JAVA黑马刘意学习笔记

目录

JAVAEE 进阶

一、快捷键

二、逻辑运算符&，|与短路逻辑运算符&&，||

三、修饰符

3.1状态修饰符

3.2权限修饰符

四、多态

五、接口

5.1成员特点：

5.2接口组成更新：

六、内部类

七、常用API

八、类型转换

九、异常处理

十、集合

10.1单列集合 Collection

10.2双列集合Map

十一、泛型：类型化参数

泛型类：

泛型方法：

泛型接口：

可变参数：

十二、Collections:

Collections常用方法：

案例：ArraysList存储学生对象并排序

案例：模拟斗地主

案例：模拟斗地主（排序版）

十三、IO流

13.1File

13.2字节流

13.3字符流

13.4复制文件的异常处理

13.5特殊操作流

十四、多线程

14.1实现多线程

14.2线程同步

14.3生产者消费者

十五、编程入门

15.1网络编程入门

15.2UDP通信程序

15.3TCP通信程序

十六、Lambda表达式

十七、方法引用

17.1方法引用符

17.2引用类方法

17.3引用对象的实例方法

17.4引用类的实例方法

17.5引用构造器

JAVAEE 进阶

JVM：为了使JAVA跨平台运行，使用JVM（JAVA虚拟机）

JRE：JAVA程序运行环境

JDK：JAVA程序开发包

一、快捷键

快速生成main方法：psvm

快速生成输出语句：sout

代码规范化：Ctrl+Alt+L

查看方法：Ctr+Alt+B

创建对象补足语句：Ctrl+Alt+V

二、逻辑运算符&，|与短路逻辑运算符&&，||

a&b——算式a，b都要进行计算

a&&b——只计算算式a。若算式a为假，算式b不执行，整体为假

a||b——判断原理如上。若算式a为真，算式b不执行，整体为真

三、修饰符

3.1状态修饰符

3.1.1final（最终态）

1.修饰方法：表明方法是最终方法，不能被重写

2.修饰变量：表明该变量是常量，不能再次被赋值。再次赋值，不能通过编译，直接报错

3.修饰类：表明该类是最终类，不能被继承，不能被子类重写，但是可以被重载。能够通过子类对象

4.修饰局部变量：变量是基本类型：final修饰的是指基本类型的数据值不能发生改变

变量是引用类型：final修饰的是引用类型的地址值不能发生改变，但地址内容可以发生改变

3.1.2static（静态）

static修饰特点：被类的所有对象共有

非静态成员方法可以访问静态和非静态的成员变量和方法，但静态成员方法只能访问静态的成员变量和成员方法

3.2权限修饰符

同一个类中 同包中子类无关类 不同包子类 不同类无关类
private √
默认 √ √
protect √ √ √
public √ √ √ √

四、多态

 public class Animal....
 public class Cat extends Animal...
   
 //向上转型
 Animal a= new Cat();
 //Cat向上转型，Animal通过子类Cat创建对象
 a.eat();
 //编译看左边，若Animal类中没有eat成员方法，则报错
 //执行看右边，使用Cat类中的eat成员方法
//向下转型
 Cat c=(Cat) a;
 //a为Animal对象，强制向下转型,转型后c可以使用子类中独有的方法

五、接口

5.1成员特点：

成员变量：只能是常量，默认修饰符public static final

构造方法：接口无构造方法，接口主要是对行为抽象，没有具体存在

成员方法：只能是抽象方法，默认修饰符public abstract

5.2接口组成更新：

默认方法：修饰符 public default，默认方法不是抽象方法，所以不强制被重写，如需重写，重写时去掉default关键字。

静态方法：修饰符 public static，静态方法只能通过接口名调用，不能通过实现类名或者对象调用。

私有方法：Java 9新增了带方法体的私有方法，当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然烤炉将这段实现代码抽取成一个共性方法，而这个共性方法是不需要让别人用的，因此用私有隐藏起来

注意：

默认方法可以调用私有静态和私有非静态

静态方法只能调用私有的静态方法

六、内部类

访问特点

1.内部类可以直接访问外部类的成员，包括私有

2.外部类要访问内部类的成员，必须创建对象

成员内部类：（公有内部类）Outer.Inner oi = new Outer().new Inner();

局部内部类：在方法中定义的类，在方法内部创建对象并使用，可以访问外部类成员和方法内的局部变量

匿名内部类：本质是一个继承该类或实现了该接口的子类匿名对象

 new Inner(){    //类名或者接口名
 public void show(){ }//重写方法
 };
 ​
 //创建对象，调用方法，通过多态方式上转
 Inner in = new Inner(){
 public void show(){ }
 };
 i.show();

七、常用API

Math类，Arrays类，System类，Object类

工具类设计思想：

1.构造方法用private修饰，防止外界创建对象

2.成员用public static修饰，使用类名访问成员方法

八、类型转换

 int---->String
   int number=100;
 String s=String.valueOf(number);
 String---->int
   //方式一
   String s="100";
 Integer i=Integer.valueOf(s);
 int x=i.intValue(i);//String-->Integer-->int

 //装箱:将基本数据类型转换为包装类类型
 Integer i =Integer.valueOf(100);//通过调用方法将100转换为对应的包装类类型
 Integer ii=100;//自动装箱，上面语句的简写方式。
 ​
 //拆箱：将包装类类型转换为基本数据类型
 ii =ii.intValue()+200;//ii.intValue()将ii转换为int类型，然后再自动装箱
 ii+=200//自动拆箱，装箱

九、异常处理

RunTimeException：运行时异常，编译不报错。除RunTimeException和其子类外，其他的都属于编译异常，必须立即处理，修改程序。

1.try...catch:捕捉异常，程序继续运行

2.throws:抛异常，不立即处理异常，延迟处理，由调用者处理

throws与throw的区别：

throws：用在方法声明后面，跟的是异常类名。表示抛出异常，由方法调用者处理。表示出现异常可能性，并不一定发生。

throw：用在方法体内，跟的是异常对象名。表示抛出异常，由方法体内的语句处理。执行throw一定抛出了某种异常。

十、集合

10.1单列集合 Collection

遍历使用Iterator迭代器

Iterator iterator():返回此集合中的元素的迭代器，通过集合的iterator()方法得到

Iterator it=c.iterator 通过集合对象c获得迭代器对象（多态）

10.1.1可重复：List

1.ArrayList

2.LinkedList 。。。

特点：输入、输出有序；元素可重复

并发修改异常：ConcurrentModificationException

产生原因：在迭代器遍历过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素时预期修改值和实际修改值不一致(通过迭代器获取元素，iterator.next()，会进行判断预期修改集合次数与实际修改集合次数是否相等，不同则抛出并发修改异常)

解决方案：通过集合使用for循环方式遍历，get方法获取元素，add方法会对实际修改集合次数进行++，但在get方法中不会对预期修改和实际修改进行判断

 //Iterator迭代器遍历
 List list = new ArrayList();
 Iterator iterator = list.Iterator();
 while(iterator.hasNext()){
 String s = iterator.next();//ConcurrentModificationException
   //源码中next方法会判断预期修改集合次数与实际修改集合次数是否相等
 if(s.equals("world")){
 list.add("javaEE");
     //源码中调用add方法后会对实际修改集合次数进行++，导致预期修改值和实际修改值不一致
 }
 }
 ​
 //解决方案
 List list1 = new ArrayList();
 Iterator iterator1 = list.Iterator();
 for(int i=0,i 
  
ListIterator：列表迭代器
 
  
1.通过List集合的ListIterator（）方法得到，是list集合特有的迭代器
 
  
2.允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的位置
 
  
增强for循环：简化数组和Collection集合的遍历方式
 
  
1.实现Iterator接口的类允许其对象成为增强型for语句目标
 
  
2.内部原理为Iterator迭代器
 
  
 List list = new ArrayList();
 Iterator iterator = list.Iterator();
 //增强for循环遍历，最方便的遍历方式
 for（String s:list）{
 System.out.println(s); 
 }
 //Iterator迭代器遍历，集合特有方式
 while(iterator.hasNext()){
 String s = iterator.next();
 System.out.println(s); 
 }
 //for循环遍历，索引方式遍历
 for(int i=0,i 
  
数据结构
 
  
常见数据结构：
 
  
栈：先进后出的模型
 
  
队列：先进先出的模型
 
  
数组：查询数据通过索引定位，查询任意数组耗时相同；删除数据时，被删除数据后每个数据前移，效率低。添加数据时，被添加数据位置后每个数据后移，效率低。
 
  
链表：一个结点，有数据域和地址域，地址域指向下一个结点的地址域。增删快，查询慢，每次查询都从头结点开始
 
  
10.1.2不可重复：set
 
  
集合特点：
 
  
1.不包含重复元素；
 
  
2.没有带索引的方法，不能使用普通for循环遍历!
 
  
根据元素的哈希值进行判断，保证元素唯一性，没有重复元素
 
  
10.1.2.1HashSet:
 
  
特点：
 
  
1.底层数据结构是哈希表（元素为链表的数组）；
 
  
2.不保证存储、取出元素顺序一致，对集合迭代顺序不做保证；
 
  
3.没有索引，不能使用普通for循环遍历；
 
  
4.没有重复元素。
 
  
HashSet集合存储元素，要保证元素的唯一性，需要重写hashCode()和equals()方法
 
  
哈希值：根据对象的地址或者字符串或数字算出来的int类型数组；Object类中有一个方法hashCode()可以获取哈希值
 
  
哈希表：将哈希值作为数组下标，把下标对应的位置作为键值对的存储位置，通过该方法建立的数组叫做哈希表
 
  
对象哈希值特点：1.同一对象多次调用hashCode()方法返回哈希值相同；2.默认情况下，不同对象哈希值不同。通过方法重写，可以让不同对象哈希值相同
 
  
HashMap保证元素唯一性：
 
  
调用对象的hashCode()方法获取对象的哈希值，根据对象的哈希值计算对象的存储位置，如果该位置已经有元素存在，先遍历该位置所有元素，和新存入的元素比较哈希值是否相同，若不相同，则存储元素到该位置，若相同则调用equals()方法比较内容是否相同，若相同则元素重复，不存储。若不同存储元素到该位置
 
  
10.1.2.2LinkedHashSet
 
  
特点：1.底层数据结构是哈希表和链表；2.具有可预测的迭代顺序，由链表保证元素有序，说明元素存入，取出顺序一致；3.由哈希表保证元素唯一，无重复元素。
 
  
10.1.2.3TreeSet
 
  
特点：1.元素有序，按照一定规则排序，具体排序方法看构造方法：无参构造，TreeSet()，元素按照自然排序进行排序；有参构造，TreeSet(Comparator comparator)，指定比较器排序。2.没有索引，不能使用普通for循环遍历；3.没有重复元素。
 
  
自然排序Comparable的使用
 
  
 //Comparator排序问题理解
 TreeSet treeset = new TreeSet(new Comparator(){
   public int compara(Student s1,Student s2){//s1为当前需要存入的元素，s2为之前存入的存入的元素
   int num=s1.getAge()-s2.getAge(); 
     //升序，若s1大于s2，num为正，则将s1顺序存入，不颠倒顺序；若s2大于s1，，num为负，则颠倒s1和s2的顺序。
     int num2 =s2.getAge()-s1.getAge();
     //降序，若s2大于s1，num2为正，将s1顺序存入，不颠倒顺序；若s1大于s2，num2为负，则颠倒s1和s2的顺序。
     return num；//升序
     //return num2;降序
  }
 });
 
  
 
  
10.2双列集合Map
 
  
     
   
  1.  
    interface Map
     
    2.  
   
  2.  
    将键映射到值的对象，不包含重复的键
     
    3.  
   
  3.  
    每个键最多可以映射到一个值
     
    4.  
   
  4.  
    创建Map对象，多态，具体实现类HashMap
     
    5.  
  
 
  
10.2.1Map常用方法：
 
  
put,remove,containsKey,containsValue,isEmpty,size.........
 
  
 public class Map_Demo {
     public static void main(String[] args) {
         Map map =new HashMap<>();
 ​
         map.put("001","linqingxia");
         map.put("002","zhangmanyu");
         map.put("003","wangzuxian");
 //       map.put("003","liuyan");//有重复的键，用值覆盖
 ​
         System.out.println(map.remove("001"));//返回被删除键对应的值
 ​
 //       map.clear();
 ​
         System.out.println(map.containsKey("002"));//true
         System.out.println(map.containsKey("004"));//false
         System.out.println(map.containsValue("zhangmanyu"));//true
 ​
         System.out.println(map.isEmpty());
 ​
         System.out.println(map.size());
         System.out.println(map);
    }
 }
 
  
获取功能：
 
  
     
   
  1.  
    V get (Object key) 根据键获取值
     
    2.  
   
  2.  
    Set  keySet() 获取所有键的集合
     
    3.  
   
  3.  
    Collection values() 获取所有值的集合
     
    4.  
   
  4.  
    Set> entrySet() 获取所有键值对对象的集合
     
    5.  
  
 
  
两种遍历方式
 
  
 qpublic class MapBianLi_Demo1 {
     public static void main(String[] args) {
         Map map =new HashMap<>();
 ​
         map.put("001","linqingxia");
         map.put("002","zhangmanyu");
         map.put("003","wangzuxian");
         //遍历方式一：Set  keySet()获取所有键的集合
         /*
         获取所有键的集合，用keySet()方法实现
         遍历键的集合，获取到每一个键。用增强for实现
         根据键去找值，用get(Object key)方法实现
         */
         Set keySet = map.keySet();
         for (String s:keySet){
             String value = map.get(s);
             System.out.println(s+","+value);
        }
         //遍历方式二：Set> entrySet()获取所有键值对对象的集合
         /*
         Set> entrySet()获取所有键值对对象的集合
         遍历键值对对象的集合，获取到每一个键值对对象。用增强for实现，得到每一个Map.Entry
         根据键值对对象获取键和值
         getKey()得到键
         getValue()得到值
         */
         Set> entrySet = map.entrySet();
         for (Map.Entry me :entrySet){
             System.out.println(me.getKey()+","+me.getValue());
        }
    }
 }
 
  
10.2.2HashMap
 
  
特点：底层数据结构为数组+链表，数组为HashMap的主体，链表则主要是为了解决哈希冲突而存在的
 
  
 public class HashMap_Demo2 {
     public static void main(String[] args) {
         HashMap hashMap = new HashMap<>();
         Student s1 =new Student("林青霞",30);
         Student s2 =new Student("张曼玉",35);
         Student s3 =new Student("王祖贤",33);
         Student s4 =new Student("王祖贤",33);
         hashMap.put(s1,"成都");
         hashMap.put(s2,"河北");
         hashMap.put(s3,"陕西");
         hashMap.put(s4,"北京");
 ​
         Set keySet = hashMap.keySet();
         for (Student key:keySet){
             String value = hashMap.get(key);
             System.out.println(key.getName()+","+key.getAge()+","+value);
        }
         System.out.println("==========================");
         Set> entrySet = hashMap.entrySet();
         for (Map.Entry me:entrySet){
             Student student=me.getKey();
             String value=me.getValue();
             System.out.println(student.getName()+","+student.getAge()+","+value);
 ​
        }
    }
 }
 
  
集合嵌套
 
  
案例：ArraysList嵌套HashMap
 
  
     
   
  •  
    需求：创建一个ArrayList集合，存储三个元素，每一个元素都是HashMap，每一个HashMap的键和值都是String，并遍历
     
    •  
   
  •  
    思路：
     
    
       
     
    •  
      1.创建一个ArrayList集合；
       
      •  
     
    •  
      2.创建HashMap集合，并添加键值对；
       
      •  
     
    •  
      3.将HashMap作为元素添加到ArrayList集合
       
      •  
     
    •  
      4.遍历ArrayList集合
       
      •  
    
    •  
  
 
  
 public class ArraysList_HashMap {
     /*
     * 需求：创建一个ArrayList集合，存储三个元素，每一个元素都是HashMap，每一个HashMap的键和值都是String，并遍历
     * 思路：1.创建一个ArrayList集合；
     *     2.创建HashMap集合，并添加键值对；
     *     3.将HashMap作为元素添加到ArrayList集合
     *     4.遍历ArrayList集合
     * */
 ​
     public static void main(String[] args) {
         ArrayList> arrays =new ArrayList<>();
 ​
         HashMap hm1=new HashMap<>();
         hm1.put("孙策","大乔");
         hm1.put("周瑜","小乔");
         arrays.add(hm1);
         HashMap hm2=new HashMap<>();
         hm2.put("郭靖","黄蓉");
         hm2.put("杨过","小龙女");
         arrays.add(hm2);
         HashMap hm3=new HashMap<>();
         hm3.put("令狐冲","任盈盈");
         hm3.put("林平之","岳灵珊");
         arrays.add(hm3);
 ​
         for (HashMap hm:arrays){
             Set keySet = hm.keySet();
             for (String key : keySet){
                 String value=hm.get(key);
                 System.out.println(key+","+value);
            }
        }
    }
 }
 
  
案例：HashMap嵌套ArrayList
 
  
     
   
  •  
    需求：创建一个HashMap集合，存储三个键值对元素，每一个键值对元素的键都是String，值是ArrayList
     
    •  
   
  •  
    思路：
     
    
       
     
    •  
      1.创建一个HashMap集合；
       
      •  
     
    •  
      2.创建ArrayList集合，并添加元素；
       
      •  
     
    •  
      3.将ArrayList作为元素添加到HashMap集合
       
      •  
     
    •  
      4.遍历HashMap集合
       
      •  
    
    •  
  
 
  
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 ​
 public class HashMap_ArrayList {
     /*
      * 需求：创建一个HashMap集合，存储三个键值对元素，每一个键值对元素的键都是String，值是ArrayList
      * 思路：1.创建一个HashMap集合；
      *     2.创建ArrayList集合，并添加元素；
      *     3.将ArrayList作为元素添加到HashMap集合
      *     4.遍历HashMap集合
      * */
     public static void main(String[] args) {
         HashMap> hashMap=new HashMap<>();
 ​
         ArrayList arrayList1=new ArrayList<>();
         arrayList1.add("诸葛亮");
         arrayList1.add("赵云");
         hashMap.put("三国演义",arrayList1);
 ​
         ArrayList arrayList2=new ArrayList<>();
         arrayList2.add("唐僧");
         arrayList2.add("孙悟空");
         hashMap.put("西游记",arrayList2);
 ​
         ArrayList arrayList3=new ArrayList<>();
         arrayList3.add("武松");
         arrayList3.add("鲁智深");
         hashMap.put("水浒传",arrayList3);
 ​
         Set>> entrySet = hashMap.entrySet();
         for (Map.Entry> m:entrySet){
             String key= m.getKey();
             ArrayList arr =m.getValue();
             System.out.println(key+":");
             for (String s:arr){
                 System.out.println("\t"+s);
            }
        }
         System.out.println("=========================");
         Set set = hashMap.keySet();
         for (String s1:set){
             ArrayList arr=hashMap.get(s1);
             System.out.println(s1+":");
             for (String s2:arr){
                 System.out.println("\t"+s2);
            }
        }
    }
 }
 
  
案例：统计字符串中每个字符出现的次数
 
  
     
   
  •  
    需求：键盘录入一个字符串，要求统计字符串中每个字符的出现次数
     
    
       
     
    •  
      输入：hello
       
      •  
     
    •  
      输出：h(1)e(1)l(2)o(1)
       
      •  
    
    •  
   
  •  
    思路：
     
    
       
     
    •  
      1.键盘录入一个字符串
       
      •  
     
    •  
      2.创建HashMap集合，键是Character，值是Integer
       
      •  
     
    •  
      3.遍历字符串，得到每一个字符
       
      •  
     
    •  
      4.拿到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
       
      •  
    
    •  
  
 
  
 import java.util.Scanner;
 import java.util.Set;
 import java.util.TreeMap;
 /*
 *   需求：键盘录入一个字符串，要求统计字符串中每个字符的出现次数
 *       输入：hello
 *       输出：h(1)e(1)l(2)o(1)
 *   思路：
 *       1.键盘录入一个字符串
 *       2.创建HashMap集合，键是Character，值是Integer
 *       3.遍历字符串，得到每一个字符
 *       4.拿到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
 * 
 * */
 public class CountWord_Demo {
     public static void main(String[] args) {
         Scanner sc =new Scanner(System.in);
         System.out.println("请输入一串字符");
         String s=sc.next();
 ​
 //       HashMap hm =new HashMap<>();//字符输出无序
         TreeMap hm =new TreeMap<>();//字符输出有序
         for (int i=0;ichar
             System.out.println(key);
             Integer value = hm.get(key);
             if (value==null){
                 hm.put(key,1);
            }else{
                 value++;
                 hm.put(key,value);
            }
        }
         
 //       StringBuilder sb =new StringBuilder();
 //       Set keySet = treeMap.keySet();
 //       for (Character key:keySet){
 //           Integer value=treeMap.get(key);
 //           sb.append(key).append("(").append(value).append(")");
 //
 //       }
 //       String result =sb.toString();
 //       System.out.println(result);
         
         Set keySet = hm.keySet();
         for (Character key:keySet){
             Integer value=hm.get(key);
             System.out.print(key+"("+value+")");
        }
    }
 }
 
  
十一、泛型：类型化参数
 
  
将类型由原来的具体的类型参数化,在使用和调用的时候传入具体类型
 
  
泛型类：
 
  
public class A{ }
 
  
泛型方法：
 
  
public  void B(T t){ }
 
  
泛型接口：
 
  
public interface C{ }
 
  
public class Cimple implement C{ }
 
  
可变参数：
 
  
public static int sum(int...a){ }
 
  
修饰符 返回类型 方法名（数据类型...变量名）{ }
 
  
注意：其中a为数组，如果参数有多个参数包含可变参数，可变参数应放在最后
 
  
十二、Collections:
 
  
针对集合操作的工具类;
 
  
其中所有方法均为静态；
 
  
Collections常用方法：
 
  
public static > void sort(List list) :将指定的列表按升序排序
 
  
public static void reverse(List list) :反转指定列表中元素的顺序
 
  
public static void shuffle(List list) :使用默认的随机源随机排序指定的列表
 
  
 import java.util.*;
 ​
 public class Collections_Demo {
     public static void main(String[] args) {
         List list = new ArrayList<>();
         list.add(20);
         list.add(50);
         list.add(30);
         list.add(70);
         list.add(60);
         list.add(40);
 //       Collections.sort(list);
 //       System.out.println(list);
         System.out.println("================");
 //       Collections.reverse(list);
 //       System.out.println(list);
         System.out.println("================");
         Collections.shuffle(list);
         System.out.println(list);
    }
 }
 
  
案例：ArraysList存储学生对象并排序
 
  
     
   
  •  
    需求：
     
    
       
     
    •  
      ArraysList存储学生对象，使用Collections对ArrayList排序
       
      •  
     
    •  
      要求：按照年龄从小到大排序，年龄相同时，按照名字首字母排序
       
      •  
    
    •  
   
  •  
    思路：
     
    
       
     
    •  
      1.定义学生类
       
      •  
     
    •  
      2.创建ArrayList集合对象
       
      •  
     
    •  
      3.创建学生对象
       
      •  
     
    •  
      4.把学生添加到集合
       
      •  
     
    •  
      5.使用Collections对集合排序
       
      •  
     
    •  
      6.遍历集合
       
      •  
    
    •  
  
 
  
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 ​
 /*
 *   需求：
 *       ArraysList存储学生对象，使用Collections对ArrayList排序
 *       要求：按照年龄从小到大排序，年龄相同时，按照名字首字母排序
 *   思路：
 *       1.定义学生类
 *       2.创建ArrayList集合对象
 *       3.创建学生对象
 *       4.把学生添加到集合
 *       5.使用Collections对集合排序
 *       6.遍历集合
 * */
 public class ArrayList_Student {
     public static void main(String[] args) {
         ArrayList arrayList=new ArrayList<>();
 ​
         Student s1 =new Student("linqingxia",30);
         Student s2 =new Student("zhangmanyu",35);
         Student s3 =new Student("wangzuxian",33);
         Student s4 =new Student("liuyan",33);
         arrayList.add(s1);
         arrayList.add(s2);
         arrayList.add(s3);
         arrayList.add(s4);
 ​
         Collections.sort(arrayList, new Comparator() {
             @Override
             public int compare(Student o1, Student o2) {
                 int num1 = o1.getAge()-o2.getAge();
                 int num2=num1==0?o1.getName().compareTo(o2.getName()):num1;
                 return num2;
            }
        });
 ​
         for (Student student:arrayList){
             System.out.println(student.getName()+","+student.getAge());
        }
    }
 }
 ​
 
  
案例：模拟斗地主
 
  
     
   
  •  
    需求：通过程序实现斗地主过程中的洗牌，发牌和看牌
     
    •  
   
  •  
    思路：
     
    
       
     
    •  
      1.创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
       
      •  
     
    •  
      2.往牌盒里装牌
       
      •  
     
    •  
      3.洗牌，把牌打散，用Collections的shuffle方法实现
       
      •  
     
    •  
      4.发牌，遍历集合，给三个玩家发牌
       
      •  
     
    •  
      5.看牌，三个玩家分别遍历自己的牌
       
      •  
    
    •  
  
 
  
/*
*   需求：通过程序实现斗地主过程中的洗牌，发牌和看牌
*   思路：
*       1.创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
*       2.往牌盒里装牌
*       3.洗牌，把牌打散，用Collections的shuffle方法实现
*       4.发牌，遍历集合，给三个玩家发牌
*       5.看牌，三个玩家分别遍历自己的牌
*
* */
public class DouDiZhu_Demo {
    public static void main(String[] args) {
        ArrayList array=new ArrayList<>();
        /*
        * ♦2，3...♦K,♦A
        * ♣2，3...♣K,♣A
        * ♥2，3...♥K,♥A
        * ♠2，3...♠K,♠A
        * 大王，小王
        * */
        //定义花色数组
        String[] colors={"♦","♣","♥","♠"};
        String[] numbers={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
        for (String color:colors){
            for (String number:numbers){
                array.add(color+number);
            }
        }
        array.add("小王");
        array.add("大王");

        Collections.shuffle(array);

        ArrayList player1=new ArrayList<>();
        ArrayList player2=new ArrayList<>();
        ArrayList player3=new ArrayList<>();
        ArrayList dpArray=new ArrayList<>();

        for (int i=0;i< array.size();i++){
            String poker = array.get(i);
            if (i>=array.size()-3){
                dpArray.add(poker);
            }else if(i%3==0){
                player1.add(poker);
            }else if(i%3==1){
                player2.add(poker);
            }else if(i%3==2) {
                player3.add(poker);
            }
        }
        lookPoker("玩家一",player1);
        lookPoker("玩家二",player2);
        lookPoker("玩家三",player3);
        lookPoker("底牌",dpArray);

    }
//    看牌的方法
    public static void lookPoker(String name,ArrayList arrayList){
        System.out.println(name+"的牌"+":");
        for (String poker:arrayList){
            System.out.print(poker+" ,");
        }
        System.out.println();
    }
}

 
  
案例：模拟斗地主（排序版）
 
  
     
   
  •  
    需求：通过程序实现斗地主过程中的洗牌，发牌和看牌,要求对牌进行排序
     
    •  
   
  •  
    思路：
     
    
       
     
    •  
      1.创建HashMap集合，键是编号，值是牌
       
      •  
     
    •  
      2.创建ArrayList集合，存储编号
       
      •  
     
    •  
      3.创建花色数组和点数数组
       
      •  
     
    •  
      4.从0开始往HashMap中存储编号，并存储对应的值，同时往ArrayList里面存储编号
       
      •  
     
    •  
      5.洗牌（洗的是编号），用Collections的shffle方法实现
       
      •  
     
    •  
      6.发牌（发的是编号），为了保证编号有序，使用TreeSet集合接收
       
      •  
     
    •  
      7.定义方法看牌，遍历TreeSet集合，获取编号，到HashMap中找对应的值
       
      •  
     
    •  
      8.调用看牌方法
       
      •  
    
    •  
  
 
  
/*
 *   需求：通过程序实现斗地主过程中的洗牌，发牌和看牌,要求对牌进行排序
 *   思路：
 *       1.创建HashMap集合，键是编号，值是牌
 *       2.创建ArrayList集合，存储编号
 *       3.创建花色数组和点数数组
 *       4.从0开始往HashMap中存储编号，并存储对应的值，同时网ArrayList里面存储编号
 *       5.洗牌（洗的是编号），用Collections的shffle方法实现
 *       6.发牌（发的是编号），为了保证编号有序，使用TreeSet集合接收
 *       7.定义方法看牌，遍历TreeSet集合，获取编号，到HashMap中找对应的值
 *       8.调用看牌方法
 * */
public class DouDiZhu_SuperDemo {
    public static void main(String[] args) {
        HashMap hm = new HashMap<>();
        ArrayList array = new ArrayList<>();
        /*
         * ♦2，3...♦K,♦A
         * ♣2，3...♣K,♣A
         * ♥2，3...♥K,♥A
         * ♠2，3...♠K,♠A
         * 大王，小王
         * */
        //定义花色数组
        String[] colors = {"♦", "♣", "♥", "♠"};
        String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        int index = 0;
        for (String number : numbers) {
            for (String color : colors) {
                hm.put(index, color + number);
                array.add(index);
                index++;
            }
        }
        hm.put(index, "小王");
        array.add(index);
        index++;
        hm.put(index, "大王");
        array.add(index);

        Collections.shuffle(array);
        TreeSet player1 = new TreeSet<>();
        TreeSet player2 = new TreeSet<>();
        TreeSet player3 = new TreeSet<>();
        TreeSet dpTree = new TreeSet<>();

        for (int i = 0; i < array.size(); i++) {
            int pokerNum = array.get(i);
            if (i >= array.size() - 3) {
                dpTree.add(pokerNum);
            } else if (i % 3 == 0) {
                player1.add(pokerNum);
            } else if (i % 3 == 1) {
                player2.add(pokerNum);
            } else if (i % 3 == 2) {
                player3.add(pokerNum);
            }
        }
        lookPoker("玩家一", player1, hm);
        lookPoker("玩家二", player2, hm);
        lookPoker("玩家三", player3, hm);
        lookPoker("底牌", dpTree, hm);

    }

    //    看牌的方法
    public static void lookPoker(String name, TreeSet treeSet, HashMap hm) {
        System.out.println(name + "的牌" + ":");
        for (Integer pokerNum : treeSet) {
            String poker = hm.get(pokerNum);
            System.out.print(poker + " ");
        }
        System.out.println();
    }
}

 
  
十三、IO流
 
  
13.1File
 
  
文件和目录路径名的抽象表示
 
  
     
   
  1.  
    文件和目录是可以 通过File封装的
     
    2.  
   
  2.  
    对与File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已，它是可以存在的，也可以是不存在的，将来是要通过具体的操作把这个路径的内容转换为具体存在。
     
    public class File_Demo {
    public static void main(String[] args) {
        
        File f1=new File("D:\\data1\\java.txt");
        System.out.println(f1);
        
        File f2=new File("D:\\data1","java.txt");
        System.out.println(f2);
        
        File f3=new File("D:\\data1");
        File f4=new File(f3,"java.txt");
        System.out.println(f4);
    }
}
     
    3.  
  
 
  
13.1.1创建功能：
 
  
     
   
  1.  
    pulic boolean createNewFile():当具有该名称的文件不存在时，创建一个由该抽象路径命名的新空文件。文件已存在，返回false。
     
    2.  
   
  2.  
    public boolean mkdir():创建由此抽象路径名命名的目录
     
    3.  
   
  3.  
    public boolean mkdirs():创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录
     
    4.  
  
 
  
13.1.2判断获取功能
 
  
     
   
  1.  
    public boolean isDirectory():测试此抽象路径名表示的File是否为目录
     
    2.  
   
  2.  
    public boolean isFile():测试此抽象路径名表示的File是否为文件
     
    3.  
   
  3.  
    public boolean exists():测试此抽象路径名表示的File是否存在
     
    4.  
   
  4.  
    public String getAbsolutePath0():返回此抽象路径名的绝对路径名字符串
     
    5.  
   
  5.  
    public String getPath():将此抽象路径名转换为路径名字符串
     
    6.  
   
  6.  
    public String getName() :返回由此抽象路径名表示的文件或目录的名称
     
    7.  
   
  7.  
    public String[] list():返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
     
    8.  
   
  8.  
    public File[] listFiles():返回此抽象路径名表示的目录中的文件和目录的File对象数组
     
    9.  
  
 
  
13.1.3递归
 
  
递归解决问题思路：
 
  
把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
 
  
递归策略只需要少量的程序就可描述出解题过程所需要的多次重复计算
 
  
递归解决问题要找到两个内容：
 
  
     
   
  •  
    递归出口：否则会出现内存溢出
     
    •  
   
  •  
    递归规则：与原问题相似的规模较小的问题
     
    •  
  
 
  
public class DiGui_Demo {
    public static void main(String[] args) {
        //每个月的兔子对数，1，1，2，3，5，8，13.。。。。
        //首先定义一个方法发f(n),表示第n个月的兔子对数
        //那么第n—1个月，f(n-1)
        int[] arr = new int[20];
        arr[0]=1;
        arr[1]=1;
        for (int i=2;i< arr.length;i++){
            arr[i]=arr[i-1]+arr[i-2];
        }
        System.out.println(arr[19]);
        System.out.println(f(20));
    }
    public static int f(int n){
        if (n==1||n==2){
            return 1;
        } else {
            return f(n-1)+f(n-2);
        }
    }
}

 
  
public class DiGui_Demo {
        public static void main(String[] args) {
            //求5的阶乘
            int n=5;
            int result=jc(5);
            System.out.println("阶乘是:"+result);
        }
        public static int jc(int n){
            if(n==1){
                return 1;
            }else{
                return n*jc(n-1);
            }
        }
}
 
  
13.1.4遍历目录
 
  
需求：给定一个路径，请通过递归遍历该目录下的所有内容，并把所有文件的绝对路径输出在控制台
 
  
思路：
 
  
     
   
  1.  
    根据给定的路径创建一个File对象
     
    2.  
   
  2.  
    定义一个方法，用于获取给定目录下的所有内容，参数为第一步创建的File对象
     
    3.  
   
  3.  
    获取给定的File目录下所有文件或目录的File数组
     
    4.  
   
  4.  
    遍历该File数组，得到每一个File对象
     
    5.  
   
  5.  
    判断该File对象是否是目录
     
    是：递归调用
     
    否：获取绝对路径输出在控制台
     
    6.  
   
  6.  
    调用方法
     
    7.  
  
 
  
public class MuLu_Demo {
    public static void main(String[] args) {
        File srcfile=new File("E:\\aixuexi");
        getAllFilePath(srcfile);

    }
    public static void getAllFilePath(File srcfile){
        File[] fileArray=srcfile.listFiles();
        if (fileArray!=null){
            for (File file:fileArray){
                if (file.isDirectory()){
                    getAllFilePath(file);
                }else {
                    System.out.println(file.getAbsoluteFile());
                }
            }
        }
    }
}
 
  
13.2字节流
 
  
IO：输入/输出
 
  
流：抽象概念，对数据传输的总称，流的本质是数据传输
 
  
IO流根据数据流向分：输入流：读数据； 输出流：写数据
 
  
IO流根据数据类型分：字节流：字节输入流，字节输出流 字符流：字符输入流，字符输出流
 
  
（由于字节流操作中文不是特别方便，所以java提供字符流）
 
  
字符流=字节流+编码表
 
  
一个汉字存储
 * GBK编码：占用两个字节      中国——>[-42,-48,-71,-6]
  	 * UTF-8编码：占用3个字节        中国——>[-28,-72,-83,-27,-101,-67]
    	* 汉字在存储的时候，第一个字符都是负数
 
  
FileOutputStream fos=new FileOutputStream("idea_test\\src\\fos.txt",true);
//追加写入数据，在文件末尾写入内容
 
  
public class FileOutPutStream_Demo01 {
    public static void main(String[] args) throws IOException {
        //创建输出流对象
        FileOutputStream fos=new FileOutputStream("idea_test\\src\\fos.txt");
//      做了三件事：A：调用系统功能创建文件  B：创建了字节流输出对象    C：让字节流输出对象指向创建好的文件
        fos.write(97);  //a
//        fos.write(57);  //9字符
//        fos.write(55);  //7字符
        //最后都要释放资源！
        fos.close();
//      做了两件事：A：关闭此文件输出流 B:并释放与此流相关的任何系统资源
    }
}
 
  
13.2.1字节流写数据加异常处理
 
  
finally：在异常处理时提供finally块来执行所有清除操作，比如说IO流中的释放资源。
 
  
try{
//可能出现异常的代码
}catch(异常类名 变量名){
//异常处理
}finally{
//执行所有的清除操作
}
 
  
13.2.2案例：复制文本文件
 
  
需求：把”E:\IDEA\idea_test\src\fos.txt"复制到模块目录下的“qyp.txt”
 
  
思路：
 
  
     
   
  1.  
    根据数据源创建字节输入流对象
     
    2.  
   
  2.  
    根据目的地创建字节输出流对象
     
    3.  
   
  3.  
    读写数据，复制文本文件（一次读取一个字节，一次写入一个字节）
     
    4.  
   
  4.  
    释放资源
     
    5.  
  
 
  
public class Copy_Demo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("idea_test\\src\\fos.txt");
        FileOutputStream fos=new FileOutputStream("idea_test\\src\\qyp.txt");
        
        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }
        fis.close();
        fos.close();
    }
}
 
  
13.2.3案例：复制图片
 
  
     
   
  •  
    需求：把”E:\qyp.JPG“复制到模块目录下的”mn.jpg“
     
    •  
   
  •  
    思路：
     
    
       
     
    •  
      1.根据数据源创建字节输入流
       
      •  
     
    •  
      2.根据目的地创建字节输出流
       
      •  
     
    •  
      3.读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组）
       
      •  
     
    •  
      4.释放资源
       
      •  
    
    •  
  
 
  
public class Copy_Demo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis=new FileInputStream("E:\\qyp.jpg");
        FileOutputStream fos=new FileOutputStream("idea_test\\src\\mn.jpg");
        
		//一次读取一个字节数组，一次写入一个字节数组
        byte[] bys=new byte[1024];
        int len;
        while ((len=fis.read(bys))!=-1){
            fos.write(bys);
        }
        fis.close();
        fos.close();


    }
}
 
  
13.2.4字节缓冲流
 
  
BufferedOutputStream:该类实现缓冲输出流。通过设置 这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用
 
  
BufferedInputStream:创建BufferedInputStream将创建一 个内部缓冲区数组。当从流中读取或跳过字节时，内部缓 冲区将根据需要从所包含的输入流中重新填充，一次很多字节
 
  
/*
* 需求：把”E:\47.avi“复制到模块目录下
* 思路：
 *   1.根据数据源创建字节输入流
 *   2.根据目的地创建字节输出流
 *   3.读写数据，复制图片（一次读取一个字节数组，一次写入一个字节数组
 *   4.释放资源
 * 四种实现方式复制视频，并记录每种方式复制视频的时间
 *  1.基本字节流一次读写一个字节     共耗时：11343毫秒
 *  2.基本字节流一次读取一个字节数组       共耗时：20毫秒
 *  3.字节缓冲流一次读取一个字节      共耗时：61毫秒
 *  4，字节缓冲流一次读取一个字节数组       共耗时：7毫秒
*/
public class Copy_Demo {
    public static void main(String[] args) throws IOException {
        long startTime=System.currentTimeMillis();
//        method1();//共耗时：11343毫秒
//        method2();//共耗时：20毫秒
//        method3();//共耗时：61毫秒
//        method4();//共耗时：7毫秒
        long stopTime=System.currentTimeMillis();
        System.out.println("共耗时："+(stopTime-startTime)+"毫秒");
    }
    public static void method1() throws IOException {
        FileInputStream fis=new FileInputStream("E:\\47.avi");
        FileOutputStream fos=new FileOutputStream("idea_test\\src\\47.avi");

        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }
        fos.close();
        fis.close();
    }

    public static void method2() throws IOException {
        FileInputStream fis=new FileInputStream("E:\\47.avi");
        FileOutputStream fos=new FileOutputStream("idea_test\\src\\47.avi");

        byte[] by=new byte[1024];
        int len;
        while ((len=fis.read(by))!=-1){
            fos.write(by,0,len);
        }
        fos.close();
        fis.close();
    }

    public static void method3() throws IOException {
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("E:\\47.avi"));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("idea_test\\src\\47.avi"));

        int by;
        while ((by=bis.read())!=-1){
            bos.write(by);
        }
        bos.close();
        bis.close();
    }

    public static void method4() throws IOException {
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("E:\\47.avi"));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("idea_test\\src\\47.avi"));

        byte[] bys=new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();
    }
}
 
  
13.2.5字符流中的编码解码问题
 
  
字符流抽象基类：
 
  
     
   
  1.  
    Reader：字符输出流的抽象类
     
    2.  
   
  2.  
    Writer：字符输出流的抽象类
     
    3.  
  
 
  
字符流中和编码解码问题相关的两个类
 
  
     
   
  1.  
    InputSreamReader
     
    2.  
   
  2.  
    OutputStreamWriter
     
    3.  
  
 
  
flush():刷新流，还可以继续写数据
 
  
close():关闭流，释放资源，但是在关闭之前会先刷新流，关闭后不能再写数据
 
  
13.2.6案例：复制Java文件
 
  
需求：把”E:\IDEA\idea_test\Copy_Demo.java"复制到模块目录下的“copy.java”
 
  
思路：
 
  
     
   
  •  
    根据数据源创建字符输入流对象
     
    •  
   
  •  
    根据目的地创建字符输出流对象
     
    •  
   
  •  
    读写数据，复制文件
     
    •  
   
  •  
    释放资源
     
    •  
  
 
  
public class Copy_Demo {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr=new InputStreamReader(new FileInputStream("idea_test\\Copy_Demo.java"));
        //解决编码问题使用 InputStreamReader和 OutputStreamReader
        OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("idea_test\\copy.java"));

//         int ch;
//         while ((ch=isr.read())!=-1){
//             osw.write(ch);
//         }

         char[] chs=new char[1024];
         int len;
         while ((len=isr.read(chs))!=-1){
             osw.write(chs,0,len);
         }
        osw.close();
        isr.close();
    }
}

//改进版，使用InputStreamReader和 OutputStreamWriter的子类FileReader和FileWriter
public class Copy_Demo {
    public static void main(String[] args) throws IOException {
		FileReader fr=new FileReader("idea_test\\Copy_Demo.java");
        FileWriter fw=new FileWriter("idea_test\\abc.java");

//        int ch;
//        while ((ch=fr.read())!=-1){
//            fw.write((char)ch);
//        }

        char[] chs =new char[1024];
        int len;
        while ((len=fr.read(chs))!=-1){
            fw.write(chs,0,len);
        }
        fw.close();
        fr.close();
    }
}
 
  
13.2.7字符缓冲流
 
  
BufferedWriter:将文本写入字符输出流，缓冲字符，以提供单个字符、数组和字符的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大。
 
  
BufferedReader:从字符输入流读取文本，缓冲字符，以提供字符、数组和行的高效读取，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大。
 
  
BufferedReader br=new BufferedReader(new FileReader("idea_test\\bw.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("idea_test\\bw.txt"));
 
  
需求：把”E:\IDEA\idea_test\Copy_Demo.java"复制到模块目录下的“Buffer.java”
 
  
思路：
 
  
     
   
  •  
    根据数据源创建字符缓冲输入流对象
     
    •  
   
  •  
    根据目的地创建字符缓冲输出流对象
     
    •  
   
  •  
    读写数据，复制文件
     
    •  
   
  •  
    释放资源
     
    •  
  
 
  
public class Copy_Demo {
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("idea_test\\Copy_Demo.java"));
        BufferedWriter bw=new BufferedWriter(new FileWriter("idea_test\\abc.java"));

        String line;
        while ((line=br.readLine())!=null){		//readLine读数据不读换行符
            bw.write(line);
            bw.newLine();
            bw.flush();
        }

        bw.close();
        br.close();
    }
}
 
  
13.2.8集合_文件
 
  
1.集合到文件
 
  
需求：把ArrayList集合中的字符串数据写入到文本文件，要求：每个字符串元作为文件中的一行数据
 
  
思路：
 
  
     
   
  •  
    创建ArrayList集合
     
    •  
   
  •  
    往集合里存储字符串元素
     
    •  
   
  •  
    创建字符缓冲输出流对象
     
    •  
   
  •  
    遍历集合，得到每一个字符串数据
     
    •  
   
  •  
    调用字符缓冲输出流的方法写数据
     
    •  
  
 
  
public class ArrayList_wenjian {
    public static void main(String[] args) throws IOException {
        ArrayList arrayList=new ArrayList<>();
        arrayList.add("hello");
        arrayList.add("world");
        arrayList.add("java");
        BufferedWriter  bw=new BufferedWriter(new FileWriter("idea_test\\array.txt"));
        for (String s:arrayList){
            bw.write(s);
            bw.newLine();
            bw.flush();
        }
        bw.close();
    }
}
 
  
2.文件到集合
 
  
需求：把文本文件中的数据读取到集合中，并遍历集合，要求：文件的每一行数据是一个集合元素
 
  
思路：
 
  
     
   
  •  
    创建字符缓冲输入流对象
     
    •  
   
  •  
    创建ArrayList集合
     
    •  
   
  •  
    调用字符缓冲输入流的方法读数据
     
    •  
   
  •  
    把读取到的字符串元素数据存储到集合中
     
    •  
   
  •  
    释放资源
     
    •  
   
  •  
    遍历集合
     
    •  
  
 
  
public class ArrayList_wenjian {
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("idea_test\\array.txt"));
        ArrayList arrayList=new ArrayList();
        String line;
        while ((line=br.readLine())!=null){
            arrayList.add(line);
        }
        br.close();
        for (String s:arrayList){
            System.out.println(s);
        }
    }
}
 
  
3.集合到文件（改进版）
 
  
需求：把ArrayList集合中的字符串数据写入到文本文件，要求：每个字符串元作为文件中的一行数据
 
  
格式：学号，姓名，年龄，居住地
 
  
思路：
 
  
     
   
  •  
    定义学生类
     
    •  
   
  •  
    创建ArrayList集合
     
    •  
   
  •  
    创建学生对象
     
    •  
   
  •  
    把学生对象存储到集合中去
     
    •  
   
  •  
    创建字符缓冲输出流对象
     
    •  
   
  •  
    遍历集合，得到每一个学生对象
     
    •  
   
  •  
    把学生对象的数据拼接成指定格式的字符串
     
    •  
   
  •  
    调用字符缓冲输出流对象的方法写数据
     
    •  
   
  •  
    释放资源
     
    •  
  
 
  
ArrayList arrayList=new ArrayList<>();
        Student s1=new Student("001","邱艳萍",20,"成都");
        Student s2=new Student("002","徐千千",21,"河北");
        Student s3=new Student("003","武旭琴",20,"山西");
        Student s4=new Student("004","唐小茹",21,"成都");
        Student s5=new Student("005","李丝萌",19,"河北");
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        arrayList.add(s5);

        BufferedWriter bw=new BufferedWriter(new FileWriter("idea_test\\array.txt"));
        for (Student student:arrayList){
            System.out.println(student.getNumber()+","+student.getName()+","+student.getAge()+","+student.getAddress());
            StringBuilder sb=new StringBuilder();
            sb.append(student.getNumber()).append(",").append(student.getName()).append(",").append(student.getAge())
                    .append(",").append(student.getAddress());
//            bw.write(student.getNumber()+","+ student.getName()+","+student.getAge()+","+student.getAddress());
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        bw.close();
 
  
4.文件到集合（改进版）
 
  
需求：把文本文件中的数据读取到集合中，要求：文件的每一行数据是一个学生对象的成员变量值 格式：学号，姓名，年龄，居住地 思路：
 
  
     
   
  •  
    定义学生类
     
    •  
   
  •  
    创建ArrayList集合
     
    •  
   
  •  
    创建字符缓冲输入流对象
     
    •  
   
  •  
    调用字符缓冲输入流对象的方法读数据
     
    •  
   
  •  
    把读取到的数据按”，“分隔，得到字符串数组
     
    •  
   
  •  
    创建学生对象
     
    •  
   
  •  
    把字符串数组中的每一个元素取出来赋值给学生对象的成员变量值
     
    •  
   
  •  
    把学生对象添加到集合
     
    •  
   
  •  
    释放资源
     
    •  
   
  •  
    遍历集合
     
    •  
  
 
  
public class ArrayList_wenjian {
    public static void main(String[] args) throws IOException {
需求：把文本文件中的数据读取到集合中，要求：文件的每一行数据是一个学生对象的成员变量值
         格式：学号，姓名，年龄，居住地
思路：
- 定义学生类
- 创建ArrayList集合
- 创建字符缓冲输入流对象
- 调用字符缓冲输入流对象的方法读数据
- 把读取到的数据按”，“分隔，得到字符串数组
- 创建学生对象
- 把字符串数组中的每一个元素取出来赋值给学生对象的成员变量值
- 把学生对象添加到集合
- 释放资源
- 遍历集合
*/
        ArrayList arrayList = new ArrayList<>();
        BufferedReader br = new BufferedReader(new FileReader("idea_test\\array.txt"));
        String line;
        while ((line = br.readLine()) != null) {
            String[] arr = line.split(",");
            Student s = new Student();
            s.setNumber(arr[0]);
            s.setName(arr[1]);
            s.setAge(Integer.parseInt(arr[2]));
            s.setAddress(arr[3]);
            arrayList.add(s);
        }
        br.close();
        for (Student student : arrayList) {
            System.out.println(student.getNumber() + "," + student.getName() + "," + student.getAge() + "," + student.getAddress());
        }

    }
}
 
  
5.集合到文件（排序版）
 
  
需求：键盘录入5个学生信息（姓名，语文成绩，数学成绩，英语成绩），要求：按照成绩总分从高到低写入文本文件
 
  
格式：姓名，语文成绩，数学成绩，英语成绩
 
  
思路：
 
  
     
   
  •  
    定义学生类
     
    •  
   
  •  
    创建TreeSet集合
     
    •  
   
  •  
    键盘录入学生数据
     
    •  
   
  •  
    创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
     
    •  
   
  •  
    把学生对象添加到TreeSet集合
     
    •  
   
  •  
    创建字符缓冲输出流对象
     
    •  
   
  •  
    遍历集合，得到每一个学生对象
     
    •  
   
  •  
    把学生对象的数据拼接成指定格式的字符串
     
    •  
   
  •  
    调用字符缓冲输出流对象的方法写数据
     
    •  
   
  •  
    释放资源
     
    •  
  
 
  
public class JiHe_wenjian {
    public static void main(String[] args) throws IOException {
/*需求：键盘录入5个学生信息（姓名，语文成绩，数学成绩，英语成绩），要求：按照成绩总分从高到低写入文本文件
格式：姓名，语文成绩，数学成绩，英语成绩
思路：
- 定义学生类
        - 创建TreeSet集合
        - 键盘录入学生数据
        - 创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
        - 把学生对象添加到TreeSet集合
        - 创建字符缓冲输出流对象
        - 遍历集合，得到每一个学生对象
        - 把学生对象的数据拼接成指定格式的字符串
        - 调用字符缓冲输出流对象的方法写数据
        - 释放资源
*/
        TreeSet treeSet=new TreeSet<>(new Comparator() {
            @Override
            public int compare(Person o1, Person o2) {
                int num = o2.getSum() - o1.getSum();
                int num2=num==0?o1.getChinese()- o2.getChinese():num;
                int num3=num2==0?o1.getMath()-o2.getMath():num2;
                int num4=num3==0?o1.getName().compareTo(o2.getName()):num3;
                return num4;
            }
        });
        for (int i=0;i<5;i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入第"+i+"学生信息");
            System.out.println("姓名：");
            String name = sc.next();
            System.out.println("语文成绩：");
            int chinese = sc.nextInt();
            System.out.println("数学成绩：");
            int math = sc.nextInt();
            System.out.println("英语成绩：");
            int english = sc.nextInt();
            Person person=new Person(name,chinese,math,english);
            treeSet.add(person);
        }
        BufferedWriter bw=new BufferedWriter(new FileWriter("idea_test\\array.txt"));
        for (Person person:treeSet){
            StringBuilder sb=new StringBuilder();
            sb.append(person.getName()).append(",").append(person.getChinese()).append(",")
                    .append(person.getMath()).append(",").append(person.getEnglish()).append(",").append(person.getSum());
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
            System.out.println(person.getName()+","+person.getChinese()+","+person.getMath()
            +","+person.getEnglish()+","+person.getSum());
        }
        bw.close();
    }
}
 
  
13.2.9案例：点名器
 
  
需求：我有一个文件里面存储了班级同学的姓名，每个姓名占一行，要求通过程序实现随机点名器
 
  
思路：
 
  
     
   
  •  
    创建字符缓冲输入流
     
    •  
   
  •  
    创建ArrayList集合对象
     
    •  
   
  •  
    调用字符缓冲输入流对象的方法读数据
     
    •  
   
  •  
    读到的字符串数据存储到集合中
     
    •  
   
  •  
    释放资源
     
    •  
   
  •  
    使用Random产生一个随机数，随机数的范围在：[0,集合的长度）
     
    •  
   
  •  
    把第六步产生的随机数作为索引到ArrayList集合中获取值
     
    •  
  
 
  
public class DianMIng_Demo {
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new FileReader("idea_test\\DianMingCe.txt"));
        ArrayList arrayList=new ArrayList<>();
        String line;
        while ((line=br.readLine())!=null){
            arrayList.add(line);
        }
        br.close();

        Random r=new Random();
        int index = r.nextInt(arrayList.size());
        String name= arrayList.get(index);
        System.out.println("幸运者是："+name);

    }
}
 
  
13.2.10案例：复制单级文件夹
 
  
需求：把“E:\IDEA_learn"这个文件夹复制到模块目录下 思路：
 
  
     
   
  •  
    创建数据源，路径是”E:\IDEA_learn“
     
    •  
   
  •  
    获取数据源目录File对象的名称（itcast）
     
    •  
   
  •  
    创建目的地目录File对象，路径名是模块名+itcast组成（idea_test\itcast)
     
    •  
   
  •  
    判断目的地目录对应的File是否存在，如果不存在，就创建
     
    •  
   
  •  
    获取数据源目录下所有文件的File数组
     
    •  
   
  •  
    遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
     
    •  
   
  •  
    获取数据源文件File对象的名称
     
    •  
   
  •  
    创建目的地文件File对象，路径名是目的地目录+mn.jpg组成（idea_test\itcast\qyp.jpg)
     
    •  
   
  •  
    复制文件，由于文件不仅仅是文本文件，还有图片、视频等文件，所以采用字节流复制文件
     
    •  
  
 
  
public class Copy_Folder {
    public static void main(String[] args) throws IOException {
        File srcFolder=new File("E:\\IDEA_learn");
        String srcFolderName = srcFolder.getName();
        File destFolder=new File("idea_test",srcFolderName);
        if (!destFolder.exists()){
            destFolder.mkdir();
        }
        File[] srcFolders = srcFolder.listFiles();
        for (File srcfile:srcFolders){
            File destFile=new File(destFolder,srcfile.getName());
            copyFile(srcfile,destFile);
        }
    }
    private static void copyFile(File srcFolder,File destFolder) throws IOException{
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFolder));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(destFolder));
        byte[] bys=new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();
    }
}
 
  
13.2.11案例：复制多级文件夹
 
  
需求：把把“E:\IDEA_learn"这个文件夹复制到F盘下 思路：
 
  
     
   
  •  
    创建数据源File对象，路径是E:\IDEA_learn
     
    •  
   
  •  
    创建目的地Fileduix，路径是F:\
     
    •  
   
  •  
    写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
     
    •  
   
  •  
    判断数据源File是否是目录
     
    
       
     
    •  
      是
       
      
         
       
      •  
        在目的地创建和数据源File名称一样的目录
         
        •  
       
      •  
        获取数据源File下所有文件或者目录的File数组
         
        •  
       
      •  
        遍历该File数组，得到每一个File对象
         
        •  
       
      •  
        把该File作为数据源File对象，递归调用复制文件夹的方法
         
        •  
      
      •  
     
    •  
      不是
       
      
         
       
      •  
        说明是文件，直接复制，用字节流
         
        •  
      
      •  
    
    •  
  
 
  
public class Copy_Folders {
    public static void main(String[] args) throws IOException {
        File srcFolder =new File("E:\\IDEA_learn");
        File destFolder=new File("F:\\");
        copyFolder(srcFolder,destFolder);
    }

    private static void copyFolder(File srcFile, File destFile) throws IOException {
        if (srcFile.isDirectory()){
            String srcFileName=srcFile.getName();
            File newFolder=new File(destFile,srcFileName);
            if (!newFolder.exists()){
                newFolder.mkdir();
            }
            File[] arr=srcFile.listFiles();
            for (File file:arr){
                copyFolder(file,newFolder);
            }
        }else {
            File newFile=new File(destFile,srcFile.getName());
            copyFiles(srcFile,newFile);
        }
    }

    private static void copyFiles(File srcFolder,File destFolder)throws IOException{
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFolder));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(destFolder));
        byte[] bys=new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();
    }
}
 
  
13.3字符流
 
  
13.4复制文件的异常处理
 
  
public class Error_Demo {
    public static void main(String[] args) {

    }

    //JDK9改进方案
    private static void method4() throws IOException {
        FileReader fr = new FileReader("fr.txt");
        FileWriter fw = new FileWriter("fw.txt");
        try (fr; fw) {
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
//自动释放资源
    }

    //JDK7改进方案
    private static void method3() {
        try (FileReader fr = new FileReader("fr.txt");
             FileWriter fw = new FileWriter("fw.txt");) {

            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
//        fw.close();
//        fr.close();
//        自动释放资源
    }

    //    try catch finally处理异常
    private static void method2() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            fr = new FileReader("fr.txt");
            fw = new FileWriter("fw.txt");
            char[] chs = new char[1024];
            int len;
            while ((len = fr.read()) != -1) {
                fw.write(chs, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (fr != null) {
                    try {
                        fr.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    //    抛出处理
    private static void method1() throws IOException {
        FileReader fr = new FileReader("fr.txt");
        FileWriter fw = new FileWriter("fw.txt");
        char[] chs = new char[1024];
        int len;
        while ((len = fr.read()) != -1) {
            fw.write(chs, 0, len);
        }
        fw.close();
        fr.close();
    }
}
 
  
13.5特殊操作流
 
  
13.5.1标准输入输出流
 
  
System类中有两个静态的成员变量：
 
  
     
   
  •  
    public static final InputStream in:标准输入流，通常该流对应键盘输入或由主机环境或用户指定的另一个输入源
     
    
       
     
    •  
      BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入一个字符串：");
String line =br.readLine();
System.out.println("请输入一个整数：");
int i=Integer.parseInt(br.readLine());
       
      •  
     
    •  
      等价于
       
      Scanner sc=new Scanner(System.in);
       
      •  
    
    •  
   
  •  
    public static final PrintStream out:标准输出流，通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标
     
    
       
     
    •  
      PrintStream ps=System.out;
       
      •  
     
    •  
      等价于System.out.println(); 本质是一个字节输出流
       
      System.out.println(100);
       
      •  
    
    •  
  
 
  
13.5.2打印流
 
  
字节打印流：PrintStream
 
  
java.lang.Object 继承者 java.io.OutputStream 继承者 java.io.FilterOutputStream 继承者 java.io.PrintStream
 
  
     
   
  •  
    PrintStream（String fileName）使用指定文件名创建新的打印流
     
    •  
   
  •  
    使用继承父类的方法写数据write，查看时会转码；使用自己的特有方法写数据print、println，查看数据原样输出
     
    •  
  
 
  
字符打印流：PrintWriter
 
  
java.lang.Object 继承者 java.io.Writer 继承者 java.io.PrintWriter
 
  
     
   
  •  
    PrintWriter(String fileName) 使用指定文件名创建新的打印流，而不需要自动执行刷新
     
    •  
  
 
  
打印流特点：
 
  
     
   
  •  
    只负责输出数据，不负责读取数据
     
    •  
   
  •  
    有自己的特有方法
     
    •  
  
 
  
13.5.3对象序列化流
 
  
对象序列化：就是将对象保存到磁盘中，或者在网络中传输对象
 
  
这种机制就是使用一个字节序列表示一个对象，该字节包括：对象的类型、对象的数据和对象中存储的属性等信息，字节序列写到文件之后，相当于文件中持久保存了一个对象的信息
 
  
反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化
 
  
对象序列化流——ObjectOutputStream
 
  
对象反序列化流——ObjectInputStream
 
  
13.5.3.1对象序列化流
 
  
对象序列化流——ObjectOutputStream
 
  
     
   
  •  
    将Java对象的原始数据类型和图形写入OutputStream，可以使用ObjectInputStream读取（重构）对象。可以通过使用流的文件来实现对象的持久存储。如果流是网络套接字流，则可以在另一个主机上或另一个进程中重构对象。
     
    •  
  
 
  
构造方法
 
  
     
   
  •  
    ObjectOutputStream（OutputStream out）:创建一个写入指定的OutputStream的ObjectOutputStream
     
    •  
  
 
  
序列化对象的方法
 
  
     
   
  •  
    void writeObject(Object obj) ：将指定的对象写入 ObjectOutputStream。
     
    •  
  
 
  
注意：
 
  
     
   
  •  
    一个对象要想被序列化，该对象所属的类必须实现Serializable接口
     
    •  
   
  •  
    Serializable是一个标记接口，实现该接口，不需要重写任何方法
     
    •  
  
 
  
public class ObjectOutPutStream_Demo {
    public static void main(String[] args) throws IOException {
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("idea_test\\src\\System_InOut\\oos.txt"));
        Student student=new Student("林青霞",30);
        oos.writeObject(student);
        oos.close();
    }
}
 
  
13.5.3.2对象反序列化流
 
  
对象反序列化流——ObjectOutputStream
 
  
     
   
  •  
    ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。
     
    •  
  
 
  
构造方法
 
  
     
   
  •  
    ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream
     
    •  
  
 
  
序列化对象的方法
 
  
     
   
  •  
    Object readObject() 从 ObjectInputStream 读取对象
     
    •  
  
 
  
public class ObjectInputStream_Demo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("idea_test\\src\\System_InOut\\oos.txt"));
        Object obj=ois.readObject();
        Student student=(Student) obj;//向下转型
        System.out.println(student.getName()+","+student.getAge());
        ois.close();
    }
}
 
  
13.5.3.3问题
 
  
用对象序列化流序列化了一个对象，假如修改了对象所属的类文件，读取数据会不会出现问题？
 
  
     
   
  •  
    java.io.InvalidClassException ​ System_InOut.Student; local class incompatible: ​ stream classdesc serialVersionUID = -5552501312078000042, ​ local class serialVersionUID = -239222344963212228 ​ 当 Serialization 运行时检测到某个类具有以下问题之一时，抛出此异常。 ​ 该类的序列版本号与从流中读取的类描述符的版本号不匹配 ​ 该类包含未知数据类型 ​ 该类没有可访问的无参数构造方法
     
    •  
  
 
  
如果出现问题，如何解决？
 
  
     
   
  •  
    强烈建议 所有可序列化类都显式声明 serialVersionUID 值， 原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性， 根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。 因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。 还强烈建议使用 private 修饰符显示声明 serialVersionUID ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;
     
    •  
  
 
  
如果一个对象中的某个成员变量的值不想被序列化，该如何实现？
 
  
     
   
  •  
    使用transient关键字修饰成员变量
     
    •  
  
 
  
13.5.4Properties
 
  
java.lang.Object 继承者 java.util.Dictionary 继承者 java.util.Hashtable 继承者 java.util.Properties
 
  
13.5.4.1Properties是一个Map体系的集合类
 
  
public class Properties_Demo {
    public static void main(String[] args) {
        public class Propertiesextends Hashtable
//        Properties prop=new Properties();
//        prop.put(001,"qyp");
//        prop.put(002,"txr");
//        prop.put(003,"lsm");
//        Set keySet= prop.keySet();
//        for (Object key:keySet){
//            Object value=prop.get(key);
//            System.out.println(key+","+value);
//        }

        Properties prop=new Properties();
//        Object setProperty(String key, String value)调用 Hashtable 的方法 put。
        prop.setProperty("001","qyp");
        prop.setProperty("002","txr");
        prop.setProperty("003","lsm");
        System.out.println(prop.getProperty("001"));
        System.out.println(prop);
        System.out.println("=========================");
        Set propertyNames = prop.stringPropertyNames();
        System.out.println(propertyNames);
        for (String key:propertyNames){
            String value=prop.getProperty(key);
            System.out.println(key+","+value);
        }
    }
} 
  
 
  
13.5.4.2Properties可以保存到流中或从流中加载
 
  
     
   
  •  
    public void load(Reader reader) throws IOException按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
     
    •  
   
  •  
    public void store(Writer writer,String comments) throws IOException以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。
     
    •  
   
  •  
    public class Properties_Demo {
    public static void main(String[] args) throws IOException {
        public class Propertiesextends Hashtable
        myStore();
        myLoad();

    }

    public static void myLoad() throws IOException{
        Properties prop=new Properties();
        FileReader fr=new FileReader("idea_test\\src\\Properties_learn\\fw.txt");
        prop.load(fr);
        fr.close();
        System.out.println(prop);
    }
    public static  void myStore() throws IOException {
        Properties prop=new Properties();
        prop.setProperty("001","qyp");
        prop.setProperty("002","txr");
        prop.setProperty("003","lsm");
        FileWriter fw=new FileWriter("idea_test\\src\\Properties_learn\\fw.txt");
        prop.store(fw,null);
        fw.close();
    }
}
     
    •  
  
 
  
13.5.4.3案例：游戏次数
 
  
需求：请写程序实现猜字小游戏，只能试玩三次，如果还想玩，提示：游戏试玩已结束，想玩请充值（www.itcast.cn)
 
  
思路：
 
  
     
   
  •  
    写一个游戏类，里面有一个猜字的小游戏
     
    •  
   
  •  
    写一个测试类，测试类中有main()方法，main()方法中按照下面步骤完成
     
    
       
     
    •  
      从文件中读取数据到Properties集合，用Load()方法实现
       
      
         
       
      •  
        文件已存在：game.txt
         
        •  
       
      •  
        里面有一个数据值：count=0
         
        •  
      
      •  
     
    •  
      通过Properties集合获取到玩游戏的次数
       
      •  
     
    •  
      判断次数是否到了三次
       
      
         
       
      •  
        如果到了，提示：游戏试玩已结束，想玩请充值（www.itcast.cn)
         
        •  
       
      •  
        如果不到，玩游戏，次数加一，重新写回文件，用Properties的store()方法实现
         
        •  
      
      •  
    
    •  
  
 
  
 
  
public class GuessNumber {
//    private GuessNumber() {
//
//    }
    public static void start(){
        Random r=new Random();
        int number=r.nextInt(100)+1;
        while(true){
            Scanner sc=new Scanner(System.in);
            System.out.println("请输入你要猜的数字：");
            int num = sc.nextInt();
            if (num==number){
                System.out.println("恭喜你猜中了");
                break;
            }else if (num>number){
                System.out.println("你猜的数字大了");
            }else{
                System.out.println("你猜的数字小了");
            }
        }
    }
}


public class Properties_test {
    public static void main(String[] args) throws IOException {
        Properties prop=new Properties();
        FileReader fr=new FileReader("idea_test\\src\\Properties_learn\\game.txt");
        prop.load(fr);
        fr.close();
//        System.out.println(prop.getProperty("count"));
        String count= prop.getProperty("count");
        int number = Integer.parseInt(count);
        if (number>=3){
            System.out.println("游戏试玩已结束，想玩请充值（www.itcast.cn)");
        }else{
            GuessNumber.start();
            number++;
            prop.setProperty("count",String.valueOf(number));
            FileWriter fw=new FileWriter("idea_test\\src\\Properties_learn\\game.txt");
            prop.store(fw,null);
            fw.close();
        }
    }
}


//game.txt
//count=0    
 
  
十四、多线程
 
  
14.1实现多线程
 
  
14.1.1进程
 
  
进程：正在运行的程序
 
  
     
   
  •  
    是系统进行资源分配和调用的独立单位
     
    •  
   
  •  
    每个进程都有它自己的内存空间和系统资源
     
    •  
  
 
  
14.1.2线程
 
  
线程：是进程中的单个顺序控制流，是一条执行路径
 
  
     
   
  •  
    单线程：一个进程如果只有一条执行路径，则称为单线程程序
     
    •  
   
  •  
    多线程：一个进程如果有多条执行路径，则称为多线程程序
     
    •  
  
 
  
14.1.3多线程的实现方式
 
  
方式一：继承Thread类
 
  
     
   
  •  
    定义一个类MyThread继承Thread类
     
    •  
   
  •  
    在MyThread类中重写run()方法
     
    •  
   
  •  
    创建MyThread类的对象
     
    •  
   
  •  
    启动线程
     
    •  
  
 
  
方式二：实现Runnable接口
 
  
     
   
  •  
    定义一个类MyRunnable实现Runnable接口
     
    •  
   
  •  
    在MyRunnable类中重写run()方法
     
    •  
   
  •  
    创建MyRunnable类的对象
     
    •  
   
  •  
    创建Thread类的对象，把MyRunnable对象作为构造方法的参数
     
    •  
   
  •  
    启动线程
     
    •  
  
 
  
相比继承Thread类，实现Runnable接口的好处
 
  
—避免了Java单继承的局限性
 
  
—适合多个相同程序的代码去处理同一个资源的情况，把线程和程序的代码、数据有效分离，较好的体现了面对对象的设计思想
 
  
14.1.4设置和获取线程名称
 
  
Thread类中设置和获取线程名称的方法
 
  
     
   
  •  
    void setName(String name) 改变线程名称为参数 name 。
     
    •  
   
  •  
    String getName() 返回该线程的名称
     
    •  
  
 
  
获取main()方法所在的线程名称：
 
  
     
   
  •  
    static Thread currentThread() 返回对当前正在执行的线程对象的引用。
     
    •  
   
  •  
    System.out.println(Thread.currentThread().getName());
     
    •  
  
 
  
14.1.5线程调度
 
  
两种调度模型：
 
  
     
   
  •  
    分时调度模型：所有线程轮流使用CPU的使用股权，平均分配每个线程占用CPU的时间片
     
    •  
   
  •  
    抢占式调度模型：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的CPU时间片相对多一点
     
    •  
  
 
  
Java使用的是抢占式调度模型，多线程程序的执行是有随机性的，因为谁抢到CPU的使用权是不一定的
 
  
Thread类中设置和获取线程优先级的方法
 
  
     
   
  •  
    int getPriority() 返回线程的优先级。
     
    •  
   
  •  
    void setPriority(int newPriority) 更改线程的优先级。
     
    •  
  
 
  
14.1.6线程控制
 
  
     
   
  •  
    static void sleep(long millis, int nanos) 在指定的毫秒数加指定的纳秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
     
    •  
   
  •  
    void join() 等待该线程终止。
     
    •  
   
  •  
    void setDaemon(boolean on) 将该线程标记为守护线程或用户线程。 当运行的线程都是守护线程时，Java虚拟机将退出
     
    •  
  
 
  
14.1.7线程生命周期
 
  
见课程《计算机操作系统》
 
  
14.2线程同步
 
  
14.2.1案例：买票
 
  
需求：某电影院目前正在上映国产大片，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
 
  
思路：
 
  
     
   
  •  
    定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets=100；
     
    •  
   
  •  
    在SellTicket类中重写run()方法实现卖票，代码步骤如下
     
    
       
     
    •  
      判断票数大于0，就卖票，并告知是哪一个窗口卖的
       
      •  
     
    •  
      卖了票之后，总票数减一
       
      •  
     
    •  
      通过sleep()方法来模拟出票时间
       
      •  
     
    •  
      票没有了，也可能有人来问，所以这里要用死循环让卖票的动作一直执行
       
      •  
    
    •  
   
  •  
    定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
     
    
       
     
    •  
      创建SellTicket类的对象
       
      •  
     
    •  
      创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应窗口名称
       
      •  
     
    •  
      启动线程
       
      •  
    
    •  
  
 
  
public class SellTicket implements Runnable{
    private int tickets=100;
    @Override
    public void run() {
        while (true) {
            if (tickets > 0) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");

                tickets--;

            }
        }
    }
}

public class SellTicket_Demo {
    public static void main(String[] args) {
        SellTicket sellTicket=new SellTicket();
        Thread thread1=new Thread(sellTicket,"窗口一：");
        Thread thread2=new Thread(sellTicket,"窗口二：");
        Thread thread3=new Thread(sellTicket,"窗口三：");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
 
  
程序出现问题：
 
  
     
   
  •  
    相同的票出现多次
     
    •  
   
  •  
    出现了复数的票
     
    •  
  
 
  
14.2.2数据安全
 
  
判断多线程程序是否会有数据安全问题的标准：
 
  
     
   
  •  
    是否是多线程环境
     
    •  
   
  •  
    是否有共享数据
     
    •  
   
  •  
    是否有多条语句操作共享数据
     
    •  
  
 
  
解决多线程安全问题：
 
  
     
   
  •  
    基本思想：让程序没有安全问题的环境
     
    •  
   
  •  
    把多条语句操作共享数据的代码锁起来，让任意时刻只能有一个线程执行即可
     
    •  
   
  •  
    Java提供了同步代码块来解决这个问题
     
    •  
  
 
  
14.2.2.1同步代码块
 
  
锁住多条语句操作共享语句
 
  
synchronized(任意对象){ //相当于给代码加锁了，任意对象可以看成是一把锁
 
  
多条语句操作共享语句
 
  
}
 
  
好处和弊端：
 
  
     
   
  •  
    好处：解决了多线程数据安全问题
     
    •  
   
  •  
    弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源，无形中会降低程序的运行效率
     
    •  
  
 
  
public class SellTicket_Demo {
    public static void main(String[] args) {
        SellTicket sellTicket=new SellTicket();
        Thread thread1=new Thread(sellTicket,"窗口一：");
        Thread thread2=new Thread(sellTicket,"窗口二：");
        Thread thread3=new Thread(sellTicket,"窗口三：");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}

public class SellTicket implements Runnable{
    private int tickets=100;
    Object obj=new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (obj){
            //thread1进来后，将这段代码进行加锁
                if (tickets > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "正在出售第" + tickets + "张票");
                    tickets--;
                }
            }
            //thread1出来后，这段代码的锁就被解开了
        }
    }
}
 
  
14.2.2.2同步方法
 
  
同步方法就是把synchronized关键字加到方法上
 
  
     
   
  •  
    格式：修饰符 synchronized 返回值类型 方法名（方法参数）{ }
     
    •  
   
  •  
    同步方法的锁对象是this
     
    •  
   
  •  
    同步静态方法：修饰符 static synchronized 返回值类型 方法名（方法参数）{ }
     
    •  
  
 
  
14.2.3线程安全的类
 
  
StringBuffer
 
  
     
   
  •  
    线程安全，可变的字符序列
     
    •  
   
  •  
    JDK5后被StringBuilder替代，StringBulider更快，因为它不执行同步
     
    •  
  
 
  
Vector
 
  
     
   
  •  
    该类改进了List接口，是Java Collections Framework的成员。与新的集合实现不同，Vector被同步
     
    •  
  
 
  
HashTable
 
  
     
   
  •  
    该类实现了一个哈希表，任何非null对象都可以用作键或者值
     
    •  
   
  •  
    从Java 2 平台 v1.2起，此类就被改进以实现 Map 接口，使它成为 Java Collections Framework 中的一个成员。不像新的 collection 实现，Hashtable 是同步的
     
    •  
  
 
  
14.3生产者消费者
 
  
生产者消费者模式概述
 
  
生产者消费者模式是个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻所谓生产者消费者问题，实际上主要是包含了两类线程:
 
  
     
   
  •  
    一类是生产者线程用于生产数据
     
    •  
   
  •  
    一类是消费者线程用于消费数据
     
    •  
  
 
  
为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
 
  
     
   
  •  
    生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
     
    •  
   
  •  
    消费者只需要从共享数据区中去获取数据， 并不需要关心生产者的行为
     
    •  
  
 
  
生产者——》共享数据区域《——消费者
 
  
为了体现生产和消费过程中的等待和唤醒，java就提供了几个方法供我们使用
 
  
     
   
  •  
    void wait() 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
     
    •  
   
  •  
    void notify() 唤醒在此对象监视器上等待的单个线程。
     
    •  
   
  •  
    void notifyAll() 唤醒在此对象监视器上等待的所有线程。
     
    •  
  
 
  
14.3.1生产者消费者案例
 
  
生产者消费者案例中包含的类:
 
  
     
   
  •  
    奶箱类(Box):定义一个成员变量，表示第x瓶奶，提供存储牛奶和获取牛奶的操作
     
    •  
   
  •  
    生产者类(Producer):实现Runnable接口， 重写run0方法，调用存储牛奶的操作
     
    •  
   
  •  
    消费者类(Customer): 实现Runnable接口，重写run0方法，调用获取牛奶的操作
     
    •  
   
  •  
    测试类(BoxDemo):里面有main方法，main方法中的代码步骤如下
     
    
       
     
    •  
      创建奶箱对象，这是共享数据区域
       
      •  
     
    •  
      创建生产者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用存储牛奶的操作
       
      •  
     
    •  
      创建消费者对象，把奶箱对象作为构造方法参数传递，因为在这个类中要调用获取牛奶的操作
       
      •  
     
    •  
      创建2个线程对象，分别把生产者对象和消费者对象作为构造方法参数传递
       
      •  
    
    •  
  
 
  
public class Box {
    private  int milk;
    //定义一个成员变量，表示奶箱状态
    private boolean state =false;

    public synchronized void put(int milk){
        //如果有牛奶等待消费
        if (state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果没有牛奶，就生产牛奶
        this.milk=milk;
        System.out.println("送奶工将第"+this.milk+"瓶奶放入奶箱");

        //生产完毕后，修改奶箱状态
        state=true;
        //唤醒其他等待的线程
        notifyAll();
    }

    public synchronized void get(){
        //如果没有牛奶，就等待生产
        if (!state){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //如果有牛奶，就消费牛奶
        System.out.println("用户拿到第"+this.milk+"瓶奶");
        //消费完成后，修改奶箱状态
        state=false;
        notifyAll();
    }
}

public class Producer implements Runnable{
    private Box b;
    public Producer(Box b){
        this.b=b;
    }
    @Override
    public void run() {
        for(int i=1;i<=30;i++){
            b.put(i);
        }
    }
}

public class Customer implements Runnable{
    private Box b;
    public Customer(Box b){
        this.b=b;
    }
    @Override
    public void run() {
        while(true){
            b.get();
        }
    }
}

public class BoxDemo {
    public static void main(String[] args) {
        Box b=new Box();
        Producer producer=new Producer(b);
        Customer customer=new Customer(b);
        Thread thread1=new Thread(producer);
        Thread thread2=new Thread(customer);
        thread1.start();
        thread2.start();
    }
}
 
  
十五、编程入门
 
  
15.1网络编程入门
 
  
15.1.1网络编程三要素
 
  
IP地址（标识网络设备）、端口（标识网络设备上的应用程序）、通信协议
 
  
IP地址：
 
  
InetAddress：此类表示Internet协议（IP）地址
 
  
     
   
  •  
    static InetAddress getByName(String host) 在给定主机名的情况下确定主机的 IP 地址。
     
    •  
   
  •  
    String getHostAddress() 返回 IP 地址字符串（以文本表现形式）。
     
    •  
   
  •  
    String getHostName() 获取此 IP 地址的主机名。
     
    •  
  
 
  
端口:
 
  
端口：设备上应用程序的唯一标识
 
  
端口号：用两个字节表示的整数，它的取值范围是065535。其中，01023之间的端口号用于一些知名的网络服务和应用，普通应用程序需要使用1024以上的端口号，如果端口号被另外一个服务或应用占用，会导致当前程序启动失败。
 
  
协议：
 
  
UDP协议：用户数据报协议，无连接通信协议，即在数据传输时。数据的发送端和接受端不建立逻辑连接。UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输。由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议
 
  
TCP协议：是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”
 
  
三次握手: TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠
 
  
     
   
  •  
    第一次握手，客户端向服务器端发出连接请求，等待服务器确认
     
    •  
   
  •  
    第二次握手，服务器端向客户端回送个响应， 通知客户端收到了连接请求
     
    •  
   
  •  
    第三次握手，客户端再次向服务器端发送确认信息，确认连接
     
    •  
  
 
  
15.2UDP通信程序
 
  
发送数据的步骤
 
  
①创建发送端的Socket对象(DatagramSocket)
 
  
DatagramSocket()
 
  
②创建数据， 并把数据打包
 
  
DatagramPacket(byte[] buf, int length, InetAddress address, int port)构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
 
  
③调用DatagramSocket对象的方法发送数据
 
  
void send(DatagramPacket p) 从此套接字发送数据报包。
 
  
④关闭发送端
 
  
void close()
 
  
 
  
接收数据的步骤
 
  
①创建接收端的Socket对象(DatagramSocket)
 
  
DatagramSocket(int port)
 
  
②创建一个数据包，用于接收数据
 
  
DatagramPacket(byte[] buf, int length)
 
  
③调用DatagramSocket对象的方法接收数据
 
  
void receive(DatagramPacketp)
 
  
④解析数据包， 并把数据在控制台显示
 
  
byte[] getData()
 
  
int getLength()
 
  
⑤关闭接收端
 
  
void close()
 
  
15.1.2案例：UDP通信程序练习
 
  
public class Send_Demo {
    public static void main(String[] args) throws IOException {
        DatagramSocket ds=new DatagramSocket();
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        String line;
        while ((line=br.readLine())!=null){
            if ("886".equals(line)){
                break;
            }
            byte[] bys=line.getBytes();
            DatagramPacket dp=new DatagramPacket(bys,bys.length, InetAddress.getByName("192.168.107.1"),12345);
            ds.send(dp);
        }
        ds.close();
    }
}

public class Receive_Demo {
    public static void main(String[] args) throws IOException {
        DatagramSocket ds=new DatagramSocket(12345);
        while (true) {
            byte[] bys = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bys, bys.length);

            ds.receive(dp);

            System.out.println("数据是：" + new String(dp.getData(), 0, dp.getLength()));
//            ds.close();
        }
    }
}
 
  
 
  
15.3TCP通信程序
 
  
发送数据的步骤
 
  
①创建客户端的Socket对象(Socket)
 
  
Socket(String host, int port)
 
  
②获取输出流，写数据
 
  
OutputStreamgetOutputStream()
 
  
③释放资源
 
  
void close()
 
  
 
  
接收数据的步骤
 
  
①创建服务器端的Socket对象(ServerSocket)
 
  
ServerSocket(int port)
 
  
②监听客户端连接， 返回个Socket对象
 
  
Socket accept()
 
  
③获取输入流， 读数据，并把数据显示在控制台
 
  
InputStream getInputStream()
 
  
④释放资源
 
  
void close()
 
  
15.1.2案例：TCP通信程序练习
 
  
public class Send_Demo {
    public static void main(String[] args) throws IOException {
        Socket soc=new Socket("192.168.107.1",10000);
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        //封装输出流对象
        BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(soc.getOutputStream()));
        String line;
        while ((line=br.readLine())!=null){
            if ("886".equals(line)){
                break;
            }

            bw.write(line);
            bw.newLine();
            bw.flush();
        }
        soc.close();
    }
}

public class Receive_Demo {
    public static void main(String[] args) throws IOException {
        ServerSocket ss=new ServerSocket(10000);
        Socket soc = ss.accept();//监听客户端的连接
        InputStream is = soc.getInputStream();
        //获取输入流
        BufferedReader br=new BufferedReader(new InputStreamReader(soc.getInputStream()));
        String line;
        while ((line=br.readLine())!=null){
            System.out.println(line);
            }

        ss.close();
    }
}
 
  
十六、Lambda表达式
 
  
Lambda表达式的三要素：形式参数，箭头，代码块
 
  
格式：(形式参数)->{代码块}
 
  
     
   
  •  
    形式参数：如果有多个参数，用逗号隔开；没有参数，留空即可
     
    •  
   
  •  
    ->：由英文中画线和大于符号组成，固定写法，代表指向动作。
     
    •  
   
  •  
    代码块：是我们具体要做的事，也就是以前我们写的方法体内容
     
    •  
  
 
  
注意：参数类型可省略；如果参数有且仅有一个，小括号可以省略；如果代码块的语句只有一条，可以省略大括号和分号；如果有return，return也可省略
 
  
前提：15.1.2案例：UDP通信程序练习
 
  
     
   
  •  
    有一个接口
     
    •  
   
  •  
    接口中有且仅有一个抽象方法
     
    •  
  
 
  
十七、方法引用
 
  
17.1方法引用符
 
  
::该符号为引用运算符，而它所在的表达式被称为方法引用
 
  
Lambda表达式：
 
  
例如：usePrintable(s->System.out.println(s));
 
  
分析：拿到参数s后通过Lambda表达式，传递给System.out.println方法处理
 
  
方法引用：
 
  
例如：usePrintable(System.out::println)
 
  
分析：直接使用System.out中的println方法来取代Lambda，代码更加简洁
 
  
推导与省略:
 
  
     
   
  •  
    如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定重载形式，它们都将被自动推导
     
    •  
   
  •  
    如果使用方法引用，同样是可以根据上下文进行推导
     
    •  
   
  •  
    方法引用是Lambda的孪生兄弟
     
    •  
  
 
  
17.2引用类方法
 
  
引用类方法，就是引用类的静态方法
 
  
格式：类名::静态方法
 
  
范例：Integer::parseInt Integer类的parseInt方法
 
  
Lambda表达式被类方法替代时，它的形式参数全部传递给静态方法作为参数
 
  
useConverter(s->Integer.parseInt(s));
 
  
改成：useConverter(Integer::parseInt)
 
  
17.3引用对象的实例方法
 
  
引用对象的实例方法，就是引用类中的成员方法
 
  
格式：对象::成员方法
 
  
范例：“HelloWorld”::toUpperCase String类中的方法，将所有字符转换为大写
 
  
Lambda表达式被对象的实例方法替代时，它的形式参数全部传递给静态方法作为参数
 
  
17.4引用类的实例方法
 
  
引用类的实例方法，就是引用类中的成员方法
 
  
格式：类名::成员方法
 
  
范例：String::subString String类中的方法，截取字符串
 
  
17.5引用构造器
 
  
引用构造器，就是引用构造方法
 
  
格式：类名::new
 
  
范例：Student::new
 
  
Lambda表达式被构造器替代时，它的形式参数全部传递给构造器作为参数
 
  

 最后附上学习地址：Java_黑马刘意(风清扬)2019最新版_Java入门视频_Java入门_Java编程_Java入门教程_黑马教程_黑马程序员_idea版_哔哩哔哩_bilibili
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    
                    
    • 
                                
  • 枚举的构造函数中抛出异常会怎样
                                    bylijinnan
javaenum单例
                                    
    首先从使用enum实现单例说起。 
 
为什么要用enum来实现单例？ 
这篇文章（ 
http://javarevisited.blogspot.sg/2012/07/why-enum-singleton-are-better-in-java.html）阐述了三个理由： 
1.enum单例简单、容易，只需几行代码： 
 

public enum Singleton {
	INSTANCE;
    
                                
    • 
                                
  • CMake 教程
                                    aigo
C++
                                    
    转自：http://xiang.lf.blog.163.com/blog/static/127733322201481114456136/ 
  
CMake是一个跨平台的程序构建工具，比如起自己编写Makefile方便很多。 
介绍：http://baike.baidu.com/view/1126160.htm 
本文件不介绍CMake的基本语法，下面是篇不错的入门教程： 
http:
    
                                
    • 
                                
  • cvc-complex-type.2.3: Element 'beans' cannot have character
                                    Cb123456
springWebgis
                                    
      cvc-complex-type.2.3: Element 'beans' cannot have character 
    Line 33 in XML document from ServletContext resource [/WEB-INF/backend-servlet.xml] is i
    
                                
    • 
                                
  • jquery实例:随页面滚动条滚动而自动加载内容
                                    120153216
jquery
                                    
    <script language="javascript">
$(function (){
	var i = 4;$(window).bind("scroll", function (event){
		//滚动条到网页头部的 高度，兼容ie,ff,chrome
		var top = document.documentElement.s
    
                                
    • 
                                
  • 将数据库中的数据转换成dbs文件
                                    何必如此
sqldbs
                                    
    旗正规则引擎通过数据库配置器（DataBuilder）来管理数据库，无论是Oracle，还是其他主流的数据都支持，操作方式是一样的。旗正规则引擎的数据库配置器是用于编辑数据库结构信息以及管理数据库表数据，并且可以执行SQL 语句，主要功能如下。 
1)数据库生成表结构信息： 
        主要生成数据库配置文件(.conf文
    
                                
    • 
                                
  • 在IBATIS中配置SQL语句的IN方式
                                    357029540
ibatis
                                    
    在使用IBATIS进行SQL语句配置查询时，我们一定会遇到通过IN查询的地方，在使用IN查询时我们可以有两种方式进行配置参数：String和List。具体使用方式如下： 
 
1.String:定义一个String的参数userIds，把这个参数传入IBATIS的sql配置文件，sql语句就可以这样写： 
 
 
 
<select id="getForms" param
    
                                
    • 
                                
  • Spring3 MVC 笔记（一）
                                    7454103
springmvcbeanRESTJSF
                                    
        
     自从 MVC 这个概念提出来之后 struts1.X  struts2.X   jsf 。。。。。 
这个view 层的技术一个接一个！ 都用过！不敢说哪个绝对的强悍！ 
要看业务，和整体的设计！ 
 
     最近公司要求开发个新系统！
    
                                
    • 
                                
  • Timer与Spring Quartz 定时执行程序
                                    darkranger
springbean工作quartz
                                    
    有时候需要定时触发某一项任务。其实在jdk1.3，java sdk就通过java.util.Timer提供相应的功能。一个简单的例子说明如何使用，很简单： 1、第一步，我们需要建立一项任务，我们的任务需要继承java.util.TimerTask package com.test; import java.text.SimpleDateFormat; import java.util.Date; 
    
                                
    • 
                                
  • 大端小端转换，le32_to_cpu 和cpu_to_le32
                                    aijuans
C语言相关
                                    
    大端小端转换，le32_to_cpu 和cpu_to_le32   字节序  
http://oss.org.cn/kernel-book/ldd3/ch11s04.html 
        小心不要假设字节序. PC 存储多字节值是低字节为先(小端为先, 因此是小端), 一些高级的平台以另一种方式(大端)
    
                                
    • 
                                
  • Nginx负载均衡配置实例详解
                                    avords

                                    
    [导读] 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡，单从字面上的意思来理解就可以解  负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。 
负载均衡 
先来简单了解一下什么是负载均衡
    
                                
    • 
                                
  • 乱说的
                                    houxinyou
框架敏捷开发软件测试
                                    
    从很久以前，大家就研究框架，开发方法，软件工程，好多！反正我是搞不明白！   
这两天看好多人研究敏捷模型，瀑布模型！也没太搞明白.    
不过感觉和程序开发语言差不多，   
瀑布就是顺序，敏捷就是循环.    
瀑布就是需求、分析、设计、编码、测试一步一步走下来。而敏捷就是按摸块或者说迭代做个循环，第个循环中也一样是需求、分析、设计、编码、测试一步一步走下来。   
  
也可以把软件开发理
    
                                
    • 
                                
  • 欣赏的价值——一个小故事
                                    bijian1013
有效辅导欣赏欣赏的价值
                                    
    　　第一次参加家长会，幼儿园的老师说："您的儿子有多动症，在板凳上连三分钟都坐不了，你最好带他去医院看一看。"　　回家的路上，儿子问她老师都说了些什么，她鼻子一酸，差点流下泪来。因为全班30位小朋友，惟有他表现最差；惟有对他，老师表现出不屑，然而她还在告诉她的儿子："老师表扬你了，说宝宝原来在板凳上坐不了一分钟，现在能坐三分钟。其他妈妈都非常羡慕妈妈，因为全班只有宝宝
    
                                
    • 
                                
  • 包冲突问题的解决方法
                                    bingyingao
eclipsemavenexclusions包冲突
                                    
    包冲突是开发过程中很常见的问题： 
其表现有： 
1.明明在eclipse中能够索引到某个类，运行时却报出找不到类。 
2.明明在eclipse中能够索引到某个类的方法，运行时却报出找不到方法。 
3.类及方法都有，以正确编译成了.class文件，在本机跑的好好的，发到测试或者正式环境就 
抛如下异常： 
 
java.lang.NoClassDefFoundError: Could not in
    
                                
    • 
                                
  • 【Spark七十五】Spark Streaming整合Flume-NG三之接入log4j
                                    bit1129
Stream
                                    
    先来一段废话： 
实际工作中，业务系统的日志基本上是使用Log4j写入到日志文件中的，问题的关键之处在于业务日志的格式混乱，这给对日志文件中的日志进行统计分析带来了极大的困难，或者说，基本上无法进行分析，每个人写日志的习惯不同，导致日志行的格式五花八门，最后只能通过grep来查找特定的关键词缩小范围，但是在集群环境下，每个机器去grep一遍，分析一遍，这个效率如何可想之二，大好光阴都浪费在这上面了
    
                                
    • 
                                
  • sudoku solver in Haskell
                                    bookjovi
sudokuhaskell
                                    
    这几天没太多的事做，想着用函数式语言来写点实用的程序，像fib和prime之类的就不想提了（就一行代码的事），写什么程序呢？在网上闲逛时发现sudoku游戏，sudoku十几年前就知道了，学生生涯时也想过用C/Java来实现个智能求解，但到最后往往没写成，主要是用C/Java写的话会很麻烦。 
  
现在写程序，本人总是有一种思维惯性，总是想把程序写的更紧凑，更精致，代码行数最少，所以现
    
                                
    • 
                                
  • java apache ftpClient
                                    bro_feng
java
                                    
    最近使用apache的ftpclient插件实现ftp下载，遇见几个问题，做如下总结。 
1. 上传阻塞，一连串的上传，其中一个就阻塞了，或是用storeFile上传时返回false。查了点资料，说是FTP有主动模式和被动模式。将传出模式修改为被动模式ftp.enterLocalPassiveMode();然后就好了。 
 
看了网上相关介绍，对主动模式和被动模式区别还是比较的模糊，不太了解被动模
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-工厂方法模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 
 


package design.pattern;

/*
 * 工厂方法模式：使一个类的实例化延迟到子类
 * 某次，我在工作不知不觉中就用到了工厂方法模式（称为模板方法模式更恰当。2012-10-29）：
 * 有很多不同的产品，它
    
                                
    • 
                                
  • 面试记录语
                                    chenyu19891124
招聘
                                    
    或许真的在一个平台上成长成什么样，都必须靠自己去努力。有了好的平台让自己展示，就该好好努力。今天是自己单独一次去面试别人，感觉有点小紧张，说话有点打结。在面试完后写面试情况表，下笔真的好难，尤其是要对面试人的情况说明真的好难。 
今天面试的是自己同事的同事，现在的这个同事要离职了，介绍了我现在这位同事以前的同事来面试。今天这位求职者面试的是配置管理，期初看了简历觉得应该很适合做配置管理，但是今天面
    
                                
    • 
                                
  • Fire Workflow 1.0正式版终于发布了
                                    comsci
工作workflowGoogle
                                    
    Fire Workflow 是国内另外一款开源工作流，作者是著名的非也同志，哈哈.... 
 官方网站是 http://www.fireflow.org 
 
 经过大家努力,Fire Workflow 1.0正式版终于发布了 
 
 正式版主要变化: 
1、增加IWorkItem.jumpToEx(...)方法，取消了当前环节和目标环节必须在同一条执行线的限制，使得自由流更加自由 
2、增加IT
    
                                
    • 
                                
  • Python向脚本传参
                                    daizj
python脚本传参
                                    
    如果想对python脚本传参数，python中对应的argc, argv(c语言的命令行参数)是什么呢？ 
需要模块：sys 
参数个数：len(sys.argv) 
脚本名：    sys.argv[0] 
参数1：     sys.argv[1] 
参数2：     sys.argv[
    
                                
    • 
                                
  • 管理用户分组的命令gpasswd
                                    dongwei_6688
passwd
                                    
    NAME：  gpasswd - administer the /etc/group file 
SYNOPSIS： 
 gpasswd group 
 gpasswd -a user group 
 gpasswd -d user group 
 gpasswd -R group 
 gpasswd -r group 
 gpasswd [-A user,...] [-M user,...] g
    
                                
    • 
                                
  • 郝斌老师数据结构课程笔记
                                    dcj3sjt126com
数据结构与算法
                                    
    <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    
                                
    • 
                                
  • yii2 cgridview加上选择框进行操作
                                    dcj3sjt126com
GridView
                                    
    页面代码
<?=Html::beginForm(['controller/bulk'],'post');?>
<?=Html::dropDownList('action','',[''=>'Mark selected as: ','c'=>'Confirmed','nc'=>'No Confirmed'],['class'=>'dropdown',])
    
                                
    • 
                                
  • linux mysql
                                    fypop
linux
                                    
    enquiry mysql version in centos linux 
yum list installed | grep mysql 
yum -y remove mysql-libs.x86_64 
enquiry mysql version in yum repositoryyum list | grep mysql oryum -y list mysql* 
install mysq
    
                                
    • 
                                
  • Scramble String
                                    hcx2013
String
                                    
    Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively. 
Below is one possible representation of s1 = "great":
    
                                
    • 
                                
  • 跟我学Shiro目录贴
                                    jinnianshilongnian
跟我学shiro
                                    
    历经三个月左右时间，《跟我学Shiro》系列教程已经完结，暂时没有需要补充的内容，因此生成PDF版供大家下载。最近项目比较紧，没有时间解答一些疑问，暂时无法回复一些问题，很抱歉，不过可以加群（334194438/348194195）一起讨论问题。 
  
  
----广告-----------------------------------------------------
    
                                
    • 
                                
  • nginx日志切割并使用flume-ng收集日志
                                    liyonghui160com

                                    
      
   nginx的日志文件没有rotate功能。如果你不处理，日志文件将变得越来越大，还好我们可以写一个nginx日志切割脚本来自动切割日志文件。第一步就是重命名日志文件，不用担心重命名后nginx找不到日志文件而丢失日志。在你未重新打开原名字的日志文件前，nginx还是会向你重命名的文件写日志，linux是靠文件描述符而不是文件名定位文件。第二步向nginx主
    
                                
    • 
                                
  • Oracle死锁解决方法
                                    pda158
oracle
                                    
    　select p.spid,c.object_name,b.session_id,b.oracle_username,b.os_user_name from v$process p,v$session a, v$locked_object b,all_objects c where p.addr=a.paddr and a.process=b.process and c.object_id=b.
    
                                
    • 
                                
  • java之List排序
                                    shiguanghui
list排序
                                    
       在Java Collection Framework中定义的List实现有Vector，ArrayList和LinkedList。这些集合提供了对对象组的索引访问。他们提供了元素的添加与删除支持。然而，它们并没有内置的元素排序支持。 　　你能够使用java.util.Collections类中的sort()方法对List元素进行排序。你既可以给方法传递
    
                                
    • 
                                
  • servlet单例多线程
                                    utopialxw
单例多线程servlet
                                    
    转自http://www.cnblogs.com/yjhrem/articles/3160864.html 
和   http://blog.chinaunix.net/uid-7374279-id-3687149.html 
Servlet 单例多线程 
Servlet如何处理多个请求访问？Servlet容器默认是采用单实例多线程的方式处理多个请求的：1.当web服务器启动的
    
                                
    •