海洋_5ad4
海洋_5ad4

java学习笔记9

序列流

  • 1.什么是序列流
    • 序列流可以把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个之后继续读第二个, 以此类推.
  • 2.使用方式
    • 整合两个: SequenceInputStream(InputStream, InputStream)
    • 整合多个: SequenceInputStream(Enumeration)
package com.heima.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class Demo1_SequenceInputStream {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        FileInputStream fis1 = new FileInputStream("a.txt");
        FileInputStream fis2 = new FileInputStream("b.txt");
        FileInputStream fis3 = new FileInputStream("c.txt");
        
        Vector v = new Vector<>();     //创建集合对象
        v.add(fis1);                                    //将流对象存储进来
        v.add(fis2);
        v.add(fis3);
        
        Enumeration en = v.elements();
        SequenceInputStream sis = new SequenceInputStream(en);  //将枚举中的输入流整合成一个
        FileOutputStream fos = new FileOutputStream("d.txt");
        
        int b;
        while((b = sis.read()) != -1) {
            fos.write(b);
        }
        
        sis.close();
        fos.close();
    }

    public static void demo2() throws FileNotFoundException, IOException {
        FileInputStream fis1 = new FileInputStream("a.txt");
        FileInputStream fis2 = new FileInputStream("b.txt");
        SequenceInputStream sis = new SequenceInputStream(fis1, fis2);
        FileOutputStream fos = new FileOutputStream("c.txt");
        
        int b;
        while((b = sis.read()) != -1) {
            fos.write(b);
        }
        
        sis.close();        //sis在关闭的时候，会将构造方法中传入的流对象也都关闭
        fos.close();
    }

    public static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis1 = new FileInputStream("a.txt");//创建字节输入流关联a.txt
        FileOutputStream fos = new FileOutputStream("c.txt");   //创建字节输出流关联c.txt
        //是创建字节输出流关联文件的时候将文件内容清空
        int b1;
        while((b1 = fis1.read()) != -1) {
            fos.write(b1);
        }
        fis1.close();
        
        FileInputStream fis2 = new FileInputStream("b.txt");
        int b2;
        while((b2 = fis2.read()) != -1) {
            fos.write(b2);
        }
        
        fis2.close();
        fos.close();
    }

}

内存输出流

package com.heima.otherio;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Demo2_ByteArrayOutputStream {

    /**
     * ByteArrayOutputStream内存输出流
     * FileInputStream读取中文的时候出现了乱码
     * 解决方案
     * 1，字符流读取
     * 2，ByteArrayOutputStream
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("e.txt");
        ByteArrayOutputStream baos = new ByteArrayOutputStream();   //在内存中创建了可以增长的内存数组
        
        int b;
        while((b = fis.read()) != -1) {
            baos.write(b);      //将读取到的数据逐个写到内存中(内存数组)
        }
        
        /*byte[] arr = baos.toByteArray();      //将缓冲区的数据全部获取出来，并赋值给arr数组
        System.out.println(new String(arr));*/
        
        System.out.println(baos.toString());    //将缓冲区的内容转换为了字符串
        fis.close();                            //toString方法可以省略，打印的时候会自动调用
    }

    public static void demo1() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("e.txt");
        byte[] arr = new byte[3];
        int len;
        while((len = fis.read(arr)) != -1) {
            System.out.println(new String(arr, 0, len));
        }
        
        fis.close();
    }

}

内存输出流之黑马面试题

package com.heima.test;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class Test1 {

    /**
     * @param args
     * 定义一个文件输入流，调用read(byte[] b)方法，将a.txt文件中的内容打印出来（byte数组大小限制为5）
     * 分析：
     * 1，read(byte[] b)是字节输入流的方法，创建FileInputStream,关联a.txt
     * 2,创建内存输出流，将读到的数据写到内存输出流中
     * 3，创建字节数组，长度为5
     * 4，将内存输出流的数据全部转换为字符串打印
     * 5，关闭输入流
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        //1，read(byte[] b)是字节输入流的方法，创建FileInputStream,关联a.txt
        FileInputStream fis = new FileInputStream("a.txt");
        //2,创建内存输出流，将读到的数据写到内存输出流中
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        //3,创建字节数组，长度为5
        byte[] arr = new byte[5];
        int len;
        
        while((len = fis.read(arr)) != -1) {
            baos.write(arr, 0, len);
        }
        //4，将内存输出流的数据全部转换为字符串打印
        System.out.println(baos);       //即使没有调用，底层也会默认帮我们toString()方法
        //5，关闭输入流
        fis.close();
    }

}

随机访问流概述和读写数据

  • A:随机访问流概述

    • RandomAccessFile概述
    • RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。
    • 支持对随机访问文件的读取和写入。

  • B:read(),write(),seek()

package com.heima.otherio;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class Demo8_RandomAccessFile {

    public static void main(String[] args) throws IOException {
        RandomAccessFile raf = new RandomAccessFile("g.txt", "rw");
        //raf.write(97); //写
        //int x = raf.read(); //读
        //System.out.println(x);
        raf.seek(10);       //在指定位置设置指针，初始值为0
        raf.write(98);
        raf.close();
    }

}

对象操作流ObjecOutputStream

1.什么是对象操作流
* 该流可以将一个对象写出, 或者读取一个对象到程序中. 也就是执行了序列化和反序列化的操作.

  • 2.使用方式
    • 写出: new ObjectOutputStream(OutputStream), writeObject()
      注意：该对象必须实现Serializable接口，表示这个类可以序列化
package com.heima.otherio;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

import com.heima.bean.Person;

public class Demo3_ObjectOutputStream {

    public static void main(String[] args) throws FileNotFoundException, IOException {
        Person p1 = new Person("张三", 23);
        Person p2 = new Person("李四", 24);
        
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));
        oos.writeObject(p1);
        oos.writeObject(p2);
        
        oos.close();
    }

}

对象操作流ObjectInputStream

  • 读取: new ObjectInputStream(InputStream), readObject()
package com.heima.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;

import com.heima.bean.Person;

public class Demo4_ObjectInputStream {

    /**
     * @param args
     * @throws IOException 
     * @throws FileNotFoundException 
     * @throws ClassNotFoundException 
     * 对象输入流，反序列化
     */
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
        
        Person p1 = (Person) ois.readObject();
        Person p2 = (Person) ois.readObject();
        //Person p3 = (Person) ois.readObject();            //当文件读取到了末尾时出现EOFException
        
        System.out.println(p1);
        System.out.println(p2);
        
        ois.close();
    }

}

对象操作流优化

package com.heima.otherio;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

import com.heima.bean.Person;

public class Demo3_ObjectOutputStream {

    public static void main(String[] args) throws FileNotFoundException, IOException {
        Person p1 = new Person("张三", 23);
        Person p2 = new Person("李四", 24);
        Person p3 = new Person("王五", 25);
        Person p4 = new Person("赵六", 26);
        
        ArrayList list = new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);
        list.add(p4);
        
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));
        oos.writeObject(list);                  //把整个集合对象一次写出
        oos.close();
    }

    public static void demo1() throws IOException, FileNotFoundException {
        Person p1 = new Person("张三", 23);
        Person p2 = new Person("李四", 24);
        
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));
        oos.writeObject(p1);
        oos.writeObject(p2);
        
        oos.close();
    }

}

package com.heima.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;

import com.heima.bean.Person;

public class Demo4_ObjectInputStream {

    /**
     * @param args
     * @throws IOException 
     * @throws FileNotFoundException 
     * @throws ClassNotFoundException 
     * 对象输入流，反序列化
     */
    public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
        ArrayList list = (ArrayList) ois.readObject();  //将集合对象一次读取
        
        for (Person person : list) {
            System.out.println(person);
        }
        
        ois.close();
    }

    public static void demo1() throws IOException, FileNotFoundException,
            ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
        
        Person p1 = (Person) ois.readObject();
        Person p2 = (Person) ois.readObject();
        //Person p3 = (Person) ois.readObject();            //当文件读取到了末尾时出现EOFException
        
        System.out.println(p1);
        System.out.println(p2);
        
        ois.close();
    }

}

加上id号

注意
* 要写出的对象必须实现Serializable接口才能被序列化
* 不用必须加id号

数据输入输出流

  • 1.什么是数据输入输出流
    • DataInputStream, DataOutputStream可以按照基本数据类型大小读写数据
    • 例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也可以按照Long类型读取, 一次读取8个字节.
  • 2.使用方式
    • DataOutputStream(OutputStream), writeInt(), writeLong()
    • DataInputStream(InputStream), readInt(), readLong()
package com.heima.otherio;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo9_Data {

    /**
     * @param args
     * @throws IOException
     * 00000000 00000000 00000011 11100101 //int类型997的二进制
     * 11100101
     * 00000000 00000000 00000000 11100101 //int类型229的二进制
     */
    public static void main(String[] args) throws IOException {
        DataInputStream dis = new DataInputStream(new FileInputStream("h.txt"));
        int x = dis.readInt();
        int y = dis.readInt();
        int z = dis.readInt();
        
        System.out.println(x);
        System.out.println(y);
        System.out.println(z);
        
        dis.close();
    }

    public static void demo3() throws FileNotFoundException, IOException {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("h.txt"));
        dos.writeInt(997);
        dos.writeInt(998);
        dos.writeInt(999);
        dos.close();
    }

    public static void demo2() throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("h.txt");
        int x = fis.read();
        int y = fis.read();
        int z = fis.read();
        
        System.out.println(x);
        System.out.println(y);
        System.out.println(z);
        
        fis.close();
    }

    public static void demo1() throws FileNotFoundException, IOException {
        FileOutputStream fos = new FileOutputStream("h.txt");
        fos.write(997); //按字节读取，997超过了一个字节的范围
        fos.write(998);
        fos.write(999);
        
        fos.close();
    }

}

打印流的概述和特点

  • 1.什么是打印流
    • 该流可以很方便的将对象的toString()结果输出, 并且自动加上换行, 而且可以使用自动刷出的模式
    • System.out就是一个PrintStream, 其默认向控制台输出信息
  • 2.使用方式
    • 打印: print(), println()
    • 自动刷出: PrintWriter(OutputStream out, boolean autoFlush, String encoding)
    • 打印流只操作数据目的
package com.heima.otherio;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;

import com.heima.bean.Person;

public class Demo5_PrintStream {

    /**
     * @param args
     * @throws FileNotFoundException 
     * PrintStream和PrintWriter分别是打印的字节流和字符流
     * 只操作数据目的
     */
    public static void main(String[] args) throws FileNotFoundException {
        //PrintWriter pw = new PrintWriter("f.txt");
        PrintWriter pw = new PrintWriter(new FileOutputStream("f.txt"), true);
        pw.println(97);         //自动刷出功能只针对的是println方法
        pw.write(97);
        pw.print(97);
        //pw.close();
    }

    public static void demo1() {
        System.out.println("aaa");
        PrintStream ps = System.out;    //获取标注输出流
        ps.println(97);     //底层通过Integer.toString()将97转换成字符串并打印
        ps.write(97);       //查找码表,找到对应的a并打印
        
        Person p1 = new Person("张三",23);
        ps.println(p1);     //默认调用p1的toString方法
        
        Person p2 = null;   //打印引用数据类型，如果是null,就打印null,如果不是null就打印对象的toString方法
        ps.println(p2);
        ps.close();
    }

}

标准输入输出流概述和输出语句

  • 1.什么是标准输入输出流(掌握)
    • System.in是InputStream, 标准输入流, 默认可以从键盘输入读取字节数据
    • System.out是PrintStream, 标准输出流, 默认可以向Console中输出字符和字节数据
  • 2.修改标准输入输出流(了解)
    • 修改输入流: System.setIn(InputStream)
    • 修改输出流: System.setOut(PrintStream)
package com.heima.otherio;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;

public class Demo6_SystemInOut {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        System.setIn(new FileInputStream("a.txt"));     //改变标准输入流
        System.setOut(new PrintStream("b.txt"));        //改变标准输出流
        
        InputStream is = System.in;     //获取标准的键盘输入流，默认指向键盘，改变后指向文件
        PrintStream ps = System.out;    //获取标准的输入流，默认指向的是控制台，改版后就指向文件
        
        int b;
        while((b = is.read()) != -1) {
            ps.write(b);
        }
        //System.out.println(); //也是一个标准输出流，不用关，因为i没有和硬盘上的文件产生关联的管道
        is.close();
        ps.close();
    }

    public static void demo1() throws IOException {
        InputStream is = System.in;
        int x = is.read();
        System.out.println(x);
        
        is.close();
        
        InputStream is2 = System.in;    //Stream closed，输入流只有一个
        int y = is2.read();
        System.out.println(y);
    }

}

修改标准输入输出流拷贝图片

package com.heima.test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;

public class Test2 {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        System.setIn(new FileInputStream("双元.jpg"));    //改变标准输入流
        System.setOut(new PrintStream("copy.jpg"));     //改变标准输出流
        
        InputStream is = System.in;
        PrintStream ps = System.out;
        
        byte[] arr = new byte[1024];
        int len;
        
        while((len = is.read(arr)) != -1) {
            ps.write(arr, 0, len);
        }
    }

}

两种方式实现键盘录入

package com.heima.otherio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

public class Demo7_SystemIn {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        /*BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); //InputStreamReader转换流
        String line = br.readLine();
        System.out.println(line);   //只能读入字符串，System.in的流可以不用关闭
*/      
        Scanner sc = new Scanner(System.in);    //更推荐下面这一种，功能更强大
        String line = sc.nextLine();
        System.out.println(line);
    }

}

Properties的概述和作为Map集合的使用

  • A:Properties的概述
    • Properties 类表示了一个持久的属性集。
    • Properties 可保存在流中或从流中加载。
    • 属性列表中每个键及其对应值都是一个字符串。
  • A:Properties的特殊功能
    • public Object setProperty(String key,String value)
    • public String getProperty(String key)
    • public Enumeration stringPropertyNames()
  • A:Properties的load()和store()功能
package com.heima.otherio;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Properties;

public class Demo10_Properties {

    /**
     * @param args
     * Properties是Hashtable的子类
     * @throws IOException 
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) throws FileNotFoundException, IOException {
        Properties prop = new Properties();
        System.out.println("读取前：" + prop);
        prop.load(new FileInputStream("config.properties"));
        System.out.println("读取后：" + prop);
        prop.setProperty("tel","18988888888");
        System.out.println("修改后：" + prop);
        prop.store(new FileOutputStream("config.properties"),"文件内可以用=号也可以用冒号"); //第二个参数是用来描述文件的，可以传null
        System.out.println("写入文件后" + prop);
    }

    public static void demo2() {
        Properties prop = new Properties();
        prop.setProperty("name", "张三");
        prop.setProperty("tel", "17764075112"); //setProperty的值不能是数字
        
        System.out.println(prop);
        Enumeration en = (Enumeration) prop.propertyNames();
        while(en.hasMoreElements()) {
            String key = en.nextElement();      //获取Properties中的每一个键
            String value = prop.getProperty(key);   //根据键获取值
            System.out.println(key + "=" + value);
        }
    }

    public static void demo1() {
        Properties prop = new Properties();
        prop.put("abc",123);
        System.out.println(prop);
    }

}

一些练习

package com.heima.test;

import java.io.File;
import java.util.Scanner;

public class Test1 {

    /**
     * @param args
     * 需求：1，从键盘接收一个文件夹路径，统计该文件夹大小
     * 
     * 从键盘接收一个文件夹路径
     * 1，创建键盘录入对象
     * 2，定义一个无限循环
     * 3，将键盘录入的结果存储并封装成File对象
     * 4，对File对象判断
     * 5，将文件夹路径对象返回
     * 
     * 统计该文件夹大小
     * 1，定义一个求和变量
     * 2，获取该文件夹下所有的文件和文件夹listFiles();
     * 3，遍历数组
     * 4，判断是文件就计算大小并累加
     * 5，判断是文件夹，递归调用
     */
    public static void main(String[] args) {
        File dir = getDir();
        System.out.println(getFileLength(dir));
        //File dir = new File("D:\\develop");   //直接计算文件夹大小没有意义，返回值是0
        //System.out.println(dir.length());
    }
    
    /*
     * 从键盘接收一个文件夹路径
     * 1，返回值类型File
     * 2，参数列表无
    */
    public static File getDir() {
        //1,创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个文件夹路径");
        //2,定义一个无限循环
        while(true) {
            //3,将键盘录入的结果存储并封装成File对象
            String line = sc.nextLine();
            File dir = new File(line);
            //4,对File对象判断
            if(!dir.exists()) {
                System.out.println("您录入的文件夹路径不存在，请输入一个文件夹路径:");
            }else if(dir.isFile()) {
                System.out.println("您录入的是文件路径，请输入一个文件夹路径:");
            }else {
                //5,将文件夹路径对象返回
                return dir;
            }
        }
    }
    
    /*
     * 统计该文件夹大小
     * 1，返回值类型long
     * 2，参数列表File dir
     */
    public static long getFileLength(File dir) {
        //1，定义一个求和变量
        long len = 0;
        //2，获取该文件夹下所有的文件和文件夹listFiles();
        File[] subFiles = dir.listFiles();
        //3，遍历数组
        for (File subFile : subFiles) {
            //4，判断是文件就计算大小并累加
            if(subFile.isFile()) {
                len = len + subFile.length();
            //5，判断是文件夹，递归调用
            }else {
                len = len + getFileLength(subFile);
            }
        }
        return len;
    }
}

package com.heima.test;

import java.io.File;

public class Test2 {

    /**
     * 需求：2，从键盘接收一个文件夹路径，删除该文件夹
     * 
     * 删除该文件夹
     * 分析：
     * 1,获取该文件夹下的所有的文件和文件夹
     * 2,遍历数组
     * 3,判断是文件直接删除
     * 4,如果是文件夹，递归调用
     * 5,循环结束后，把空文件夹删掉
     */
    public static void main(String[] args) {
        File dir = Test1.getDir();
        deleteFile(dir);
    }
    
    /*
     * 删除该文件夹
     * 1,返回值类型void
     * 2,参数列表File dir
     */
    public static void deleteFile(File dir) {
        //1,获取该文件夹下的所有的文件和文件夹
        File[] subFiles = dir.listFiles();
        //2,遍历数组
        for (File subFile : subFiles) {
            //3,判断是文件直接删除
            if(subFile.isFile()) {
                subFile.delete();
            //4,如果是文件夹，递归调用
            }else {
                deleteFile(subFile);
            }
        }
        //5,循环结束后，把空文件夹删掉
        dir.delete();   //如果上面的for循环里面没有递归调用，则会删除文件夹。
    }
}

package com.heima.test;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test3 {

    /**
     * 需求：3,从键盘接收两个文件夹路径，把其中一个文件夹(包含内容)拷贝到另一个文件夹中
     * 
     * 把其中一个文件夹(包含内容)拷贝到另一个文件夹中
     * 分析:
     * 1，在目标文件夹中创建原文件夹
     * 2，获取原文件夹中所有的文件和文件夹，存储在File数组中
     * 3，遍历数组
     * 4，如果是文件就用io流读写
     * 5，如果是文件夹就递归调用
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        File src = Test1.getDir();
        File dest = Test1.getDir();
        if(src.equals(dest)) {
            System.out.println("目标文件夹是源文件夹的子文件夹");
        }else {
            copy(src, dest);
        }
        
    }
    /*
     * 把其中一个文件夹(包含内容)拷贝到另一个文件夹中
     * 1，返回类型void
     * 2，参数列表File src,File dest
     */
    public static void copy(File src, File dest) throws IOException {
        //1，在目标文件夹中创建原文件夹
        File newDir = new File(dest, src.getName());
        newDir.mkdir();
        //2，获取原文件夹中所有的文件和文件夹，存储在File数组中
        File[] subFiles = src.listFiles();
        //3，遍历数组
        for (File subFile : subFiles) {
            //4，如果是文件就用io流读写
            if(subFile.isFile()) {
                BufferedInputStream bis = new BufferedInputStream(new FileInputStream(subFile));
                BufferedOutputStream bos = new BufferedOutputStream(
                        new FileOutputStream(new File(newDir, subFile.getName())));
                int b;
                while((b = bis.read()) != -1) {
                    bos.write(b);   
                }
                
                bis.close();
                bos.close();
            //5，如果是文件夹就递归调用
            }else {
                copy(subFile, newDir);
            }       
        }
    }

}

package com.heima.test;

import java.io.File;

public class Test4 {

    /**
     * 需求:4,从键盘接收一个文件夹路径，把文件夹中的所有文件以及文件夹的名字按层级打印， 例如:
     * 把文件夹中的所有文件以及文件夹的名字按层级打印
     * 分析:
     * 1，获取所有文件和文件夹，返回File数组
     * 2，遍历数组
     * 3，无论是文件还是文件夹，都需要直接打印
     * 4，如果是文件夹，递归调用
     */
    public static void main(String[] args) {
        File dir = Test1.getDir();
        printLev(dir, 0);
    }

    public static void printLev(File dir,int lev) {
        //1，获取所有文件和文件夹，返回File数组
        File[] subFiles = dir.listFiles();
        //2，遍历数组
        for (File subFile : subFiles) {
            for(int i = 0; i <= lev; i++) {
                System.out.print("\t");
            }
            //3，无论是文件还是文件夹，都需要直接打印
            System.out.println(subFile);
            //4，如果是文件夹，递归调用
            if(subFile.isDirectory()) {
                printLev(subFile, lev + 1);
            }
        }
    }

}

package com.heima.test;

public class Test5 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //demo1();
        System.out.println(fun(8));
    }

    public static void demo1() {
        //斐波那契数列
        long[] arr = new long[100];
        arr[0] = 1;
        arr[1] = 1;
        //遍历数组对其他元素赋值
        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i-2] + arr[i-1];
        }
        //打印
        System.out.println(arr[arr.length - 1]);
    }
    
    /*
     * 用递归求斐波那契数列
     */
    public static int fun(int num) {
        if(num == 1 || num == 2) {
            return 1;
        }else {
            return  fun(num - 2) + fun(num - 1);
        }
    }

}

package com.heima.test;

import java.math.BigInteger;

public class Test6 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        BigInteger bi1 = new BigInteger("1");   //获取1000的阶乘尾部有多少个0
        for (int i = 1; i <= 1000; i++) {
            BigInteger bi2 = new BigInteger(i+"");
            bi1 = bi1.multiply(bi2);    //将bi1与bi2相乘的结果赋值给bi1
        }
        String str = bi1.toString();    //获取字符串表现形式
        StringBuilder sb = new StringBuilder(str);
        str = sb.reverse().toString();  //链式编程
        
        int i = 0;                  //定义计算器
        for (i = 0; i < str.length(); i++) {
            if('0' != str.charAt(i)) {
                break;
            }
        }
        
        System.out.println(i);
    }

    public static void demo1() {    //求1000的阶乘中所有的零
        BigInteger bi1 = new BigInteger("1");
        for (int i = 1; i <= 1000; i++) {
            BigInteger bi2 = new BigInteger(i+"");
            bi1 = bi1.multiply(bi2);    //将bi1与bi2相乘的结果赋值给bi1
        }
        String str = bi1.toString();    //获取字符串表现形式
        int count = 0;
        for (int i = 0; i < str.length(); i++) {
            if('0' == str.charAt(i)) {  //如果字符串中出现了0字符
                count++;                //计算器加1
            }
        }
        System.out.println(count);
    }

}

package com.heima.test;

import java.util.ArrayList;

public class Test8 {

    /**
     * @param args
     * 约瑟夫环
     * * 幸运数字
     */
    public static void main(String[] args) {
        System.out.println(getLucklyNum(100));
    }

    /*
     * 获取幸运数字
     * 1,返回值类型int
     * 2,参数列表int num
     */
    public static int getLucklyNum(int num) {
        ArrayList list = new ArrayList<>();        //创建集合存储1到num的对象
        for(int i = 1; i <= num; i++) {
            list.add(i);                                    //将1到num存储在集合中
        }
        
        int count = 1;                                      //用来数数的,只要是3的倍数就杀人
        for(int i = 0; list.size() != 1; i++) {             //只要集合中人数超过1,就要不断的杀
            if(i == list.size()) {                          //如果i增长到集合最大的索引+1时
                i = 0;                                      //重新归零
            }
            
            if(count % 3 == 0) {                            //如果是3的倍数
                list.remove(i--);                               //就杀人
            }
            count++;
        }
        
        return list.get(0);
    }
}

你可能感兴趣的:(java学习笔记9)

  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 抖音乐买买怎么加入赚钱?赚钱方法是什么 测评君高省
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
  • 每日一题——第八十九题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
  • 2022-07-08 保利学府里李楚怡1307022
    ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
  • 每日一题——第八十三题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
  • 《庄子.达生9》 钱江潮369
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
  • 2019-12-22-22:30 涓涓1016
    今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
  • 谁家酒器最绝唱，藏在酒厂人未知？景阳冈酒厂先秦藏品大揭秘 李虓酒评论
    文/王赛时中国的酒器酒具历史久远，举世闻名。从北京的故宫博物院、中国国家博物馆，到世界各国的大型博物馆，都以能够收藏中国古代酒具而夸耀。但很少有人知道，在山东阳谷景阳冈酒厂，默默地收藏了两千件中国酒器。这些酒器，就封藏在景阳冈的酒道馆里。其中有一些青铜酒器，一睡就是三、四千年，堪称无声国宝，堪作无字史书！今天，我将引领诸位首先窥视一下景阳冈酒道馆的9件先秦藏品，你自己来说震撼不震撼。提示：这只是景
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 今又重阳 芮峻
    今又重阳图片发自App白露成霜菊花黄，岁岁重阳，今又重阳。登高远望，君不见，那来时路上少年，青丝已染雪霜。落日一点一点西坠，谁有力量，托住使其回往。转眼缺了大半，又能怎样？江天两茫茫。给我一壶烈酒，我要敬那斜阳，看谁先醉？笑指西天红了一片，借点酒力，老夫聊发一次少年狂。老严.2019年重阳节.杭州
  • 2020.11.19 隆非凡
    日精进，今日体验：在维修过程中遇到的问题，把源头找到，在进行下一步开始。不要停留在一个点上，合理调整心态，把当下事做好。
  • 《中华小厨师》单行VS爱藏：姜是老的辣，书是新的好 cicoky
    《汉书·郦食其传》有曰：“王者以民为天，而民以食为天。”自古以来，吃饱饭是每一个人的基本要求，而吃好饭却是每一个人的最终追求。于是，厨师这一职业孕育而生，其渊源之久，甚至可追溯到4000年前的奴隶时代。职业本身无贵贱，但职业能力却有高低之分。所以一家餐馆生意好不好，厨师的水平决定一切，而站在所有厨师顶端的就被称之为“特级厨师”。今天要说的就是一个关于“特级厨师刘昴星”的故事。连载历程1995年第4
  • 运城寻访重逢石头纪实【严建设老照片395 集】 我简直能把你想透， 当我走进运城的时候。 我已急得热汗直流， 访问了十九个老头， 把晋南的小城转了三周。 虽然是悠久的思旧， 我仍然是牛样的执... 严建设
    运城寻访重逢石头纪实【严建设老照片395集】我简直能把你想透，当我走进运城的时候。我已急得热汗直流，访问了十九个老头，把晋南的小城转了三周。虽然是悠久的思旧，我仍然是牛样的执拗。说什么变换的世情，泛起了过去的逝流，你就是真正的故友。踏破铁鞋的淡愁，已化为不废功夫的范畴，是就像远在天涯近在咫尺，就像是梦乡的邂逅，我紧紧地攥着你的手。你已长成了高高的个头，俊逸的容颜却很清瘦，你那样顽皮的童音，已变到老
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 398顺境，逆境 戴骁勇
    2018.11.27周二雾霾最近儿子进入了一段顺境期，今天表现尤其不错。今天的数学测试成绩喜人，没有出现以往的计算错误，整个卷面书写工整，附加题也在规定时间内完成且做对。为迎接体育测试的锻炼有了质的飞跃。坐位体前屈成绩突飞猛进，估测成绩能达到12cm，这和上次测试的零分来比，简直是逆袭。儿子还在不断锻炼和提升，唯恐到时候掉链子。跑步姿势在我的调教下，逐渐正规起来，速度随之也有了提升。今晚测试的50
  • 2019-08-08 65454
    东莞家庭聚会出行旅游去哪里玩住？想起来有很久没有和家里人聚会啦，这次组织家人来到威廉古堡别墅轰趴，一大家子27个人，在别墅订了一天办，玩的非常的开心，小孩子玩游戏机，也很放心不会丢，我们就在唱歌、打麻将、打桌球一系列的活动，还准备小次等小孩生日在别墅举办，还可以给孩子做一个生日的策划
  • 2.0践行没有你的参与就不完美 x秀丽x
    亲爱的伙伴们早上好，今天早上我们开了一次班委竞选的会议，全程只有20多个人参与，宫班本着对大家负责任的态度告诉我们，此次竞选作废，原因是这没有达到2.0的100%参会要求，如果没有大家的参与那么这个班委选出来还有什么意义，这说明选出来的人也是不一定是我们大家心目中认可的那个人，所以为了让大家的这个90天能够更好的激发出自己的的“做”的能力，那么要从第一次竞选班委的会议开始做到100%出席会议，竞选
  • libyuv之linux编译 jaronho Linuxlinux运维服务器
    文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
  • 没想到，真没想到 一棵落花的树
    生活中，每一件小事都蕴藏着他的道理。有些令你意外，却能让你收到更为意外的结果。那一次，我真没想到的事，让我收获了爱。记忆的雨飘落下来，扰乱了我平静的心湖。那是一次数学考试，我破天荒地考了“99”分。我不禁沾沾自喜，这成绩我可不容易得到，妈妈一定会好好表扬我的。回到家，我想妈妈得意的报出成绩，妈妈只是淡淡的说：“嗯，等会儿试卷拿给我看看。”做完作业，我把试卷拿给了妈妈。只见妈妈捧着试卷，眯着眼睛盯着
  • 百善孝为先 杜友顺
    2018年11月29日天气~晴星期四找点空闲找点时间领着孩子常回家看看带上笑容带上祝福陪同爱人常回家看看家，永远是儿女们幸福温暖的港湾，那里有我们日夜思念的父母，有着彼此的牵挂，无论走到哪里，家永远是避风雨的港湾。今天没事，和媳妇回了趟老家，看看父母，回到家，房间里不算凌乱，可是细心的我发现有的地方已经沾满了灰尘，桌子上父亲不离手的烟灰缸也弹满了烟灰。几个马上就要腐烂掉的水果蔫耷的搭拉着脑袋躺在了
  • CX8903：Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片 诚芯微科技 社交电子
    CX8903：电动Ebike自行车仪表电源方案开发,Ebike智能仪表电源芯片推荐。电动助力自行车EBIKE凭借其环保、健康、低噪、和便捷等特点，成为了越来越受欢迎的骑行便利交通工具。提供电动Ebike自行车仪表电源方案开发、E-BIKE电动助力自行车仪表供电电源解决方案。CX8903采用100V高压制造工艺（芯片最高耐压可到100V以上），SOP-8L贴片封装，CX8903内置100V/90mΩ
  • 2020-12-16 长寿富贵
    9：56不知今天哪位亲来说说话呀？成萌：尽尽皆是道。道道皆相同。不解呀？成萌：郁郁不得志，混混过日子。哦……说谁的呀？成萌：说自己呀……还能说谁呢？那如何办呢？成萌：回头……如何回头？成萌：回见心源。如何回见心源？成萌：不追不随诸相迁，如如不动在心田。啊？成萌：慢慢守心吧。
  • 自我意识 徐立华
    ----读帕克.帕尔默《教学勇气》（P18----19）5.铸造我们的学科帕克.帕尔默说学科知识对我们的自身认同和外部世界有启发意义。学科会铸造我们。“在我们与学科的命题概念和学科的生活框架相遇之前，自我意识知识处于潜伏状态，通过回想学科是怎样唤醒自我意识，我们就可以找回教学心灵。”《教学勇气》（P18）我们的自我意识像冰山表面下无限延伸的冰层，常常处于潜伏状态。但是在我们对所教授的学科进行深入思
  • 2018-12-29 枫叶红时总多离别
    2018年12月29日星期六昨天老师就告诉我们，今天下午不用上课，是图书漂流活动会。我觉得很兴奋，好期待。到了下午，我帮好忙就到外面去买书，刚一出去，就有一大帮的大哥哥、大姐姐围着我问要不要买书，买一本书送一颗糖。我看到了一本《小老虎比上树》的书，问大姐姐多少钱，大姐姐说这本书原价13块，现在便宜4块钱也就是9块钱卖给你，我就把一张10块钱给她找，她找了我一块钱。我现在想想我今天只带了10块钱，现
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • 多线程编程之卫生间 周凡杨 java并发卫生间线程厕所
    如大家所知，火车上车厢的卫生间很小，每次只能容纳一个人，一个车厢只有一个卫生间，这个卫生间会被多个人同时使用，在实际使用时，当一个人进入卫生间时则会把卫生间锁上，等出来时打开门，下一个人进去把门锁上，如果有一个人在卫生间内部则别人的人发现门是锁的则只能在外面等待。问题分析：首先问题中有两个实体，一个是人，一个是厕所，所以设计程序时就可以设计两个类。人是多数的，厕所只有一个（暂且模拟的是一个车厢）。
  • How to Install GUI to Centos Minimal sunjing linuxInstallDesktopGUI
    http://www.namhuy.net/475/how-to-install-gui-to-centos-minimal.html   I have centos 6.3 minimal running as web server. I’m looking to install gui to my server to vnc to my server. You can insta
  • Shell 函数 daizj shell函数
    Shell 函数 linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。 shell中函数的定义格式如下： [function] funname [()]{ action; [return int;] } 说明： 1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。 2、参数返回
  • Linux服务器新手操作之一 周凡杨 Linux 简单 操作
    1.whoami      当一个用户登录Linux系统之后，也许他想知道自己是发哪个用户登录的。      此时可以使用whoami命令。      [ecuser@HA5-DZ05 ~]$ whoami       e
  • 浅谈Socket通信（一） 朱辉辉33 socket
    在java中ServerSocket用于服务器端，用来监听端口。通过服务器监听，客户端发送请求，双方建立链接后才能通信。当服务器和客户端建立链接后，两边都会产生一个Socket实例，我们可以通过操作Socket来建立通信。    首先我建立一个ServerSocket对象。当然要导入java.net.ServerSocket包    ServerSock
  • 关于框架的简单认识 西蜀石兰 框架
    入职两个月多，依然是一个不会写代码的小白，每天的工作就是看代码，写wiki。 前端接触CSS、HTML、JS等语言，一直在用的CS模型，自然免不了数据库的链接及使用，真心涉及框架，项目中用到的BootStrap算一个吧，哦，JQuery只能算半个框架吧，我更觉得它是另外一种语言。 后台一直是纯Java代码，涉及的框架是Quzrtz和log4j。 都说学前端的要知道三大框架，目前node.
  • You have an error in your SQL syntax; check the manual that corresponds to your 林鹤霄
    You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'option,changed_ids  ) values('0ac91f167f754c8cbac00e9e3dc372
  • MySQL5.6的my.ini配置 aigo mysql
    注意：以下配置的服务器硬件是：8核16G内存    [client]   port=3306   [mysql]   default-character-set=utf8     [mysqld]   port=3306   basedir=D:/mysql-5.6.21-win
  • mysql 全文模糊查找 便捷解决方案 alxw4616 mysql
    mysql 全文模糊查找 便捷解决方案 2013/6/14 by 半仙 [email protected] 目的: 项目需求实现模糊查找. 原则: 查询不能超过 1秒. 问题: 目标表中有超过1千万条记录. 使用like '%str%' 进行模糊查询无法达到性能需求. 解决方案: 使用mysql全文索引. 1.全文索引 : MySQL支持全文索引和搜索功能。MySQL中的全文索
  • 自定义数据结构 链表(单项 ,双向,环形) 百合不是茶 单项链表双向链表
         链表与动态数组的实现方式差不多,    数组适合快速删除某个元素    链表则可以快速的保存数组并且可以是不连续的       单项链表;数据从第一个指向最后一个   实现代码:        //定义动态链表 clas
  • threadLocal实例 bijian1013 javathreadjava多线程threadLocal
    实例1： package com.bijian.thread; public class MyThread extends Thread { private static ThreadLocal tl = new ThreadLocal() { protected synchronized Object initialValue() { return new Inte
  • activemq安全设置—设置admin的用户名和密码 bijian1013 javaactivemq
            ActiveMQ使用的是jetty服务器, 打开conf/jetty.xml文件，找到 <bean id="adminSecurityConstraint" class="org.eclipse.jetty.util.security.Constraint"> <p
  • 【Java范型一】Java范型详解之范型集合和自定义范型类 bit1129 java
    本文详细介绍Java的范型，写一篇关于范型的博客原因有两个，前几天要写个范型方法(返回值根据传入的类型而定)，竟然想了半天，最后还是从网上找了个范型方法的写法；再者，前一段时间在看Gson, Gson这个JSON包的精华就在于对范型的优雅简单的处理，看它的源代码就比较迷糊，只其然不知其所以然。所以，还是花点时间系统的整理总结下范型吧。   范型内容 范型集合类 范型类
  • 【HBase十二】HFile存储的是一个列族的数据 bit1129 hbase
    在HBase中，每个HFile存储的是一个表中一个列族的数据，也就是说，当一个表中有多个列簇时，针对每个列簇插入数据，最后产生的数据是多个HFile，每个对应一个列族，通过如下操作验证   1. 建立一个有两个列族的表   create 'members','colfam1','colfam2'   2. 在members表中的colfam1中插入50*5
  • Nginx 官方一个配置实例 ronin47 nginx 配置实例
    user www www; worker_processes 5; error_log logs/error.log; pid logs/nginx.pid; worker_rlimit_nofile 8192; events { worker_connections 4096;} http { include conf/mim
  • java-15.输入一颗二元查找树，将该树转换为它的镜像， 即在转换后的二元查找树中，左子树的结点都大于右子树的结点。 用递归和循环 bylijinnan java
    //use recursion public static void mirrorHelp1(Node node){ if(node==null)return; swapChild(node); mirrorHelp1(node.getLeft()); mirrorHelp1(node.getRight()); } //use no recursion bu
  • 返回null还是empty bylijinnan javaapachespring编程
    第一个问题，函数是应当返回null还是长度为0的数组（或集合）？ 第二个问题，函数输入参数不当时，是异常还是返回null？ 先看第一个问题 有两个约定我觉得应当遵守： 1.返回零长度的数组或集合而不是null（详见《Effective Java》） 理由就是，如果返回empty，就可以少了很多not-null判断： List<Person> list
  • [科技与项目]工作流厂商的战略机遇期 comsci 工作流
          在新的战略平衡形成之前，这里有一个短暂的战略机遇期，只有大概最短6年，最长14年的时间，这段时间就好像我们森林里面的小动物，在秋天中，必须抓紧一切时间存储坚果一样，否则无法熬过漫长的冬季。。。。         在微软，甲骨文，谷歌，IBM,SONY
  • 过度设计-举例 cuityang 过度设计
    过度设计，需要更多设计时间和测试成本，如无必要，还是尽量简洁一些好。 未来的事情，比如 访问量，比如数据库的容量，比如是否需要改成分布式  都是无法预料的 再举一个例子，对闰年的判断逻辑： 　　1、 if($Year%4==0) return True; else return Fasle; 　　2、if (   ($Year%4==0  &am
  • java进阶，《Java性能优化权威指南》试读 darkblue086 java性能优化
    记得当年随意读了微软出版社的.NET 2.0应用程序调试，才发现调试器如此强大，应用程序开发调试其实真的简单了很多，不仅仅是因为里面介绍了很多调试器工具的使用，更是因为里面寻找问题并重现问题的思想让我震撼，时隔多年，Java已经如日中天，成为许多大型企业应用的首选，而今天，这本《Java性能优化权威指南》让我再次找到了这种感觉，从不经意的开发过程让我刮目相看，原来性能调优不是简单地看看热点在哪里，
  • 网络学习笔记初识OSI七层模型与TCP协议 dcj3sjt126com 学习笔记
      协议：在计算机网络中通信各方面所达成的、共同遵守和执行的一系列约定 　　计算机网络的体系结构：计算机网络的层次结构和各层协议的集合。 　　两类服务： 　　面向连接的服务通信双方在通信之前先建立某种状态，并在通信过程中维持这种状态的变化，同时为服务对象预先分配一定的资源。这种服务叫做面向连接的服务。 　　面向无连接的服务通信双方在通信前后不建立和维持状态，不为服务对象
  • mac中用命令行运行mysql dcj3sjt126com mysqllinuxmac
    参考这篇博客：http://www.cnblogs.com/macro-cheng/archive/2011/10/25/mysql-001.html  感觉workbench不好用（有点先入为主了）。 1，安装mysql 在mysql的官方网站下载 mysql 5.5.23 http://www.mysql.com/downloads/mysql/，根据我的机器的配置情况选择了64
  • MongDB查询（1）——基本查询[五] eksliang mongodbmongodb 查询mongodb find
    MongDB查询 转载请出自出处：http://eksliang.iteye.com/blog/2174452 一、find简介 MongoDB中使用find来进行查询。 API:如下 function ( query , fields , limit , skip, batchSize, options ){.....}  参数含义： query:查询参数 fie
  • base64，加密解密 经融加密，对接 y806839048 经融加密对接
    String data0 = new String(Base64.encode(bo.getPaymentResult().getBytes(("GBK")))); String data1 = new String(Base64.decode(data0.toCharArray()),"GBK"); // 注意编码格式，注意用于加密，解密的要是同
  • JavaWeb之JSP概述 ihuning javaweb
      什么是JSP？为什么使用JSP？ JSP表示Java Server Page，即嵌有Java代码的HTML页面。使用JSP是因为在HTML中嵌入Java代码比在Java代码中拼接字符串更容易、更方便和更高效。   JSP起源    在很多动态网页中，绝大部分内容都是固定不变的，只有局部内容需要动态产生和改变。  如果使用Servl
  • apple watch 指南 啸笑天 apple
    1. 文档 WatchKit Programming Guide（中译在线版 By @CocoaChina） 译文 译者 原文 概览 - 开始为 Apple Watch 进行开发 @星夜暮晨 Overview - Developing for Apple Watch 概览 - 配置 Xcode 项目 - Overview - Configuring Yo
  • java经典的基础题目 macroli java编程
    1.列举出 10个JAVA语言的优势 a:免费，开源，跨平台(平台独立性)，简单易用，功能完善，面向对象，健壮性，多线程，结构中立，企业应用的成熟平台, 无线应用 2.列举出JAVA中10个面向对象编程的术语 a:包，类，接口，对象，属性，方法，构造器，继承，封装，多态，抽象，范型 3.列举出JAVA中6个比较常用的包 Java.lang;java.util;java.io;java.sql;ja
  • 你所不知道神奇的js replace正则表达式 qiaolevip 每天进步一点点学习永无止境纵观千象regex
    var v = 'C9CFBAA3CAD0'; console.log(v); var arr = v.split(''); for (var i = 0; i < arr.length; i ++) { if (i % 2 == 0) arr[i] = '%' + arr[i]; } console.log(arr.join('')); console.log(v.r
  • [一起学Hive]之十五-分析Hive表和分区的统计信息(Statistics) superlxw1234 hivehive分析表hive统计信息hive Statistics
    关键字：Hive统计信息、分析Hive表、Hive Statistics   类似于Oracle的分析表，Hive中也提供了分析表和分区的功能，通过自动和手动分析Hive表，将Hive表的一些统计信息存储到元数据中。   表和分区的统计信息主要包括：行数、文件数、原始数据大小、所占存储大小、最后一次操作时间等；   14.1 新表的统计信息 对于一个新创建
  • Spring Boot 1.2.5 发布 wiselyman spring boot
        Spring Boot 1.2.5已在7月2日发布，现在可以从spring的maven库和maven中心库下载。   这个版本是一个维护的发布版，主要是一些修复以及将Spring的依赖提升至4.1.7(包含重要的安全修复)。   官方建议所有的Spring Boot用户升级这个版本。   项目首页 | 源
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他