Easy coding
Easy coding

Java学习笔记整理-知识梳理+JDK1.8详细文档

链接：java开发手册
提取码：kes8
链接：JDK1.8详细文档
提取码：n9zo

JavaSE 面向对象编程（Object-oriented programming）

封装

类(class)

类的声明

两种类型的类声明:

普通类声明

class 类名 {}

枚举声明

enum 类名 {}

PS:如果一个类与其任何包含的类或接口具有相同的简单名称，则是编译时错误。

类的构成

成员变量（属性），成员方法，构造方法，初始化块，静态块

对象

对象是类的具体实现。一切皆对象。

class和Java源文件的关系

  • 类的 名称和Java源文件的名称必须保持一致
  • Java源文件只能包含一个public class
  • Java源文件如果包含多个类，则会生成多个.class文件

Package

作用：防止名称冲突，好区分同名类。

package语句必须放在类定义的最前面

访问修饰符

public 公开的、共享的、 private 私有的 、 protected 受保护的 、缺省或默认的访问权限

private访问权限：同类

public访问权限：所有人

protected访问权限：同类，同包，子类

默认的访问权限：同类，同包

构造方法

  • 方法名称跟类名保持一致；

  • 没有定义构造方法时，编译器会自动创建一个默认的无参的构造方法；

  • 构造方法的作用是在new的时候，初始化对象的属性，或者做其他初始化工作；

    JVM规范定义：所有的构造方法在编译之后的方法名为<init>，返回的类型为Class类型，只能被JVM调用。

方法重载

重载的条件：

  1. 同一个类中
  2. 方法名相同
  3. 两个及以上个数的方法的参数类型不同或参数的个数不同或参数的顺序不同
  4. 不看返回类型

this

指向当前对象

this()可以调用本类的重载构造方法，且this()调用必须放在第一行

static

静态属性：能被所有对象所共享，在内存中只有一个副本，它当且仅当在类的初始化加载时会被初始化。

静态方法：在静态方法中不能访问非静态成员变量和非静态成员方法。

静态代码块：static块可以置于类中的任何地方，类中可以有多个static块。在初始化被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

通过类名.静态方法或静态属性调用。

对象的构建顺序

父类的静态块->子类的静态块->父类的初始化块->父类的构造方法子类的->子类的初始化块->子类的构造方法

静态块：在类的加载期间，做static初始化工作，针对于当前类的静态属性。
    
初始化块：初始化块在虚拟机编译之后，会生成一个<clinit>方法

继承

所有类的父类都指向Object类

super

指向当前父类的对象

super()来调用父类的构造方法，且super()调用必须放在第一行

Abstract

Abstract Class(抽象类)

抽象类，不具体、不完整的类。

当一个类定义为抽象类之后，就不能被实例化。

抽象类可以没有抽象方法，有抽象方法的类一定是抽象类。

当一个非抽象子类继承了抽象类就必须对抽象方法进行实现，并且子类的方法和参数必须和父类保持一致。

抽象方法

abstract可以用来修饰方法，代表这个方法为抽象方法，此方法不能有具体的实现。

方法重写

  • 子类重写父类的方法
  • 子类的访问修饰符要大于或等于父类的访问修饰符
  • 子类的返回类型要小于或等于父类的返回类型
  • 子类的方法参数必须跟父类保持一致
  • 父类如果throws是CheckedException,那么子类声明的时候，CheckedException一定是小于父类的
  • 父类如果throws是RuntimeException，那么子类声明的时候，可以忽略

多态

  • 父类的引用指向子类的对象

父类的引用只能调用父类定义的方法

父类的引用如果要调用子类定义的方法，需要将父类的引用强转为子类的类型

强制转换的时候，建议使用instanceof运算符进行判断（防止对象的引用是引用数据类型的特殊值null）

  • 多态是指，针对某个类型方法的调用，其真正执行的方法取决于运行时期实际类型的方法

final

修饰类

当前类不能被继承

修饰方法

当前方法不能被Override

修饰变量

  • 栈区的值不能被更改；
  • final修饰local variable 这个值只能被赋值一次；
  • final修饰属性，此属性必须在构造方法里，或构造方法之前赋值，且只能被赋值一次；
  • final修饰引用数据类型,可以修改堆中的数据。

接口（Interface ）

  • 接口不能实例化
  • 所有成员变量被public static final修饰
  • 一个类可以实现（implements)多个接口

接口和抽象类的区别

接口是对行为的规范，抽象类是对数据模板的规范。

abstract class interface
继承 只能extends一个class 可以implements多个interface
字段 可以定义实例字段 不能定义实例字段
抽象方法 可以定义抽象方法 可以定义抽象方法
非抽象方法 可以定义非抽象方法 可以定义default方法

数组

数组是一个包含固定数量的单一类型值的容器对象。 创建数组时将确定数组的长度

数组的创建方式

int[] anArray = new int[10];
int[] anArray = { 100, 200, 300};

访问数组下标为i的元素

数组的首地址+i*数组的元素的大小

特点

  • 大小一致
  • 长度固定
  • 排列连续

内部类

指的的一个public类的内部定义另外一个类

分类

  • 静态内部类（Static Nested Class）
  • 非静态内部类（Inner Class）
  • 匿名内部类（Anonymous Class）

Java.lang学习笔记

java.lang.Object

  • toString()

    返回对象字符串描述,也可以理解为返回对象的值.可以被子类重写。

  • hashCode()

    返回对象的”内存地址”的哈希算法值,可以被子类重写

  • equals(Object obj)

比较两个对象是否是同一个对象，可以被子类重写。

  • finalize()

    当没有任何引用指向对象时,该对象被销毁前,由java垃圾回收器调用该方法,进行”清理工作”.如:关闭I/0、数据库链接、网络连接等.该方法可以被子类重写。

/**
 * 学生类
 */
public class Student {
    //学号
    private String stuNo;
    //姓名
    private String name;

    public Student() {
    }

    public Student(String stuNo, String name) {
        this.stuNo = stuNo;
        this.name = name;
    }

    public String getStuNo() {
        return stuNo;
    }

    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "学号:" + this.stuNo + ",姓名:" + this.name;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Student) {
            //强制转换成学生
            Student otherStu = (Student) obj;
            if (this.stuNo.equals(otherStu.stuNo)) {
                return true;
            } else {
                return false;
            }
        } else {
            //如果是其它类型对象,返回false,表示对象值不相等
            return false;
        }
    }


    @Override
    public int hashCode() {
        return null != this.stuNo ? this.stuNo.hashCode() : 0;
    }

    /**
     * 当没有任何引用指向对象时,该对象被销毁前,由java垃圾回收器调用
     * 该方法,进行"清理工作".如:关闭I/0、数据库链接、网络连接等,该方法
     * 可以被子类重写
     */

    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println(this.name + "即将被销毁...");
    }

    public static void main(String[] args) {
        Student stu = new Student("011", "小明");
        System.out.println(stu.toString());
        Student stu2 = new Student("012", "小明");
        System.out.println(stu2.equals(stu2));
        System.out.println(stu2.hashCode());
        //获取该对象所有class类型对象
        Class stuClass = stu2.getClass();
        System.out.println(stuClass);
        stu2 = null;
        //运行java垃圾回收器
        System.gc();
        //Runtime.getRuntime().gc();
    }
}

java.lang.String

  • String对象一旦创建后，其栈区内容、长度不可以改变。（由final修饰的char数组）
  • String对象可以存放在常量区，堆内存中。
String str1 = "abc";
String str2 = new String("abc中");
//获取字符串长度,即字符串中字符的数量
int count = str2.length();
System.out.println(count);
//字符串索引0到长度-1
for (int index = 0; index < count; index++) {
    char ch = str2.charAt(index);
    System.out.println(ch);
}
//转大小写
str2=str2.toUpperCase();//转大写
System.out.println(str2);
String baidu="https://www.baidu.com";
//字符串截取,获取子字符串
System.out.println(baidu.substring(12,17));
System.out.println(baidu.substring(12));
//字符串替换
baidu="https://www.baidu.com?wd=www.taobao.com";
System.out.println(baidu.replace("www","***"));
//查找子字符串
//查找"https://www.baidu.com?wd=www.taobao.com";是否包含www
System.out.println(baidu.indexOf("www"));
int i=baidu.indexOf('.');
System.out.println(baidu.indexOf("www",i));
System.out.println(baidu.lastIndexOf("www"));
//字符串拼接
//String  str3="abc"+1+true;
String  str3="abc"+"123";
System.out.println(str3);
String str6="123";
System.out.println(str6.concat("abc"));
//去左右两边空格
String str7=" 12 3 ";
System.out.println(str7.trim());
//字符串分割
String str8="ab;cd;ef";
String [] strs= str8.split(";");
for(String str:strs){
    System.out.println(str);
}
//比较两个字符串是否相等
String  strA=new String("abc");
String  strB=new String("abc");
System.out.println(strA.equals(strB));//区分大小写
System.out.println(strA.equalsIgnoreCase(strB));//不区分大小写
System.out.println(strA==strB);
//将其它对象转换成字符串,如:123->"123"
String str9= String.valueOf(123);
String str = "123";
String str1 = "123";
//equals比较两个字符串是否是同一个字符串
System.out.println(str.equals(str1));
//==比较两个字符串引用是否指向同一个字符串对象
System.out.println(str == str1);
String str3 = new String("abc");
String str4 = new String("abc");
System.out.println(str3.equals(str4));
System.out.println(str3 == str4);

java.lang.StringBuilder

线程非安全的,多线程环境效率高于StringBuffer

java.lang.StringBuffer

线程安全的,同步的.现实方式和使用与StringBuilder相同

手写简化版的StringBuffer

public class MyStringBuffer {

	private char[] value;

	private int length;

	public MyStringBuffer(int capacity) {
		if (capacity <= 0) {
			value = new char[16];
		}
		value = new char[capacity];
	}

	public MyStringBuffer(String str) {
		this(str.length() + 16);
		append(str);

	}

	public void append(char c) {
		/*
		 * if (value.length < length + 1) { expansion(); } value[length++] = c;
		 */
		append(new char[] { c });
	}

	public void append(char[] str) {
		if (value.length < length + str.length) {
			expansion();
		}
		System.arraycopy(str, 0, value, this.length, str.length);
		this.length = this.length + str.length;
	}

	public void append(String str) {
		/*
		 * char[] array = str.toCharArray(); if (value.length < array.length + length) {
		 * expansion(); } System.arraycopy(array, 0, value, this.length, array.length);
		 * this.length = this.length + str.length();
		 */
		 append(str.toCharArray());
	}

	public void delete(int start, int end) {
		if (start < 0) {
			throw new StringIndexOutOfBoundsException(start);
		}
		if (end > length) {
			end = length;
		}
		if (start > end) {
			throw new StringIndexOutOfBoundsException();
		}

		int len = end - start;
		if (len > 0) {
			System.arraycopy(value, start + len, value, start, length - end);
			length -= len;
		}
	}

	public int indexof(String str) {
		/*
		 * char[] array = str.toCharArray(); 
		 * char first = array[0];
		 *  int index = -1;
		 * for (int i = 0; i < length; i++) { 
		 * if (value[i] != first) { continue; } 
		 * int count = 1; 
		 * for (int j = 1; j < array.length; j++) { 
		 * if ((i + j) >= length) {
		 * break; } 
		 * if (value[i + j] != array[j]) 
		 * { break; } 
		 * count++; } // 条件匹配即退出 
		 * if(count == array.length) { 
		 * index = i; break; } } 
		 * return index;
		 */
		int index = -1;
		char[] array = str.toCharArray();
		for (int i = 0; i < length; i++) {
			boolean flag = true;
			for (int j = 0; j < array.length; j++) {
				if (array[j] != value[i + j]) {
					flag = false;
					break;
				}
			}
			if (flag) {
				index = i;
				break;
			}
		}
		return index;
	}

	public int lastIndexof(String str) {
		int index = -1;
		char[] array = str.toCharArray();
		for (int i = length - array.length; i >= 0; i--) {
			boolean flag = true;
			for (int j = array.length - 1; j >= 0; j--) {
				if (array[j] != value[i + j]) {
					flag = false;
					break;
				}
			}
			if (flag) {
				index = i - array.length + 1;
				break;
			}
		}
		return index;
	}

	public void insert(int offset, char[] str) {
		if ((offset < 0) || (offset > value.length)) {
			throw new StringIndexOutOfBoundsException(offset);
		}
		if (value.length < length + str.length) {
			expansion();
		}
//        for (int i = length - 1; i >= offset; i--) {
//            value[i + str.length] = value[i];
//        }
		System.arraycopy(value, offset, value, offset + str.length, length - offset);
		System.arraycopy(str, 0, value, offset, str.length);
		length = length + str.length;
	}

	public int Length() {
		return length;
	}

	public String subString(int start, int end) {
		char[] array = new char[end - start];
		System.arraycopy(value, start, array, 0, end - start);
		return String.valueOf(array);
	}

	/**
	 * 清除左右空格
	 */
	public void trim() {
		char[] array = new char[length];
		int begin = 0;
		int end = 0;
		for (int i = 0; i < length; i++) {
			if (!Character.isSpaceChar(value[i])) {
				begin = i;
				break;
			}
		}
		delete(0, begin);
		for (int i = length - 1; i >= 0; i--) {
			if (!Character.isSpaceChar(value[i])) {
				end = i;
				break;
			}
		}
		delete(end + 1, length);
	}

	public char charAt(int index) {
		while (index >= 0 && index < length) {
			return value[index];
		}
		throw new ArrayIndexOutOfBoundsException(index);
	}

	@Override
	public String toString() {
		char[] array = new char[length];
		System.arraycopy(value, 0, array, 0, length);
		return String.valueOf(array);
	}

	/**
	 * 扩容
	 */
	public void expansion() {
		char[] bigValue = new char[value.length * 2];
		System.arraycopy(value, 0, bigValue, 0, length);
		value = bigValue;
	}

}

java.lang.Math

Math类就是用来进行数学计算的，它提供了大量的静态方法来便于我们实现数学计算。

求绝对值：

Math.abs(-100); // 100
Math.abs(-7.8); // 7.8

取最大或最小值：

Math.max(100, 99); // 100
Math.min(1.2, 2.3); // 1.2

计算xy次方：

Math.pow(2, 10); // 2的10次方=1024

计算√x：

Math.sqrt(2); // 1.414...

计算ex次方：

Math.exp(2); // 7.389...

计算以e为底的对数：

Math.log(4); // 1.386...

计算以10为底的对数：

Math.log10(100); // 2

三角函数：

Math.sin(3.14); // 0.00159...Math.cos(3.14); // -0.9999...Math.tan(3.14); // -0.0015...Math.asin(1.0); // 1.57079...Math.acos(1.0); // 0.0

Math还提供了几个数学常量：

double pi = Math.PI; // 3.14159...double e = Math.E; // 2.7182818...Math.sin(Math.PI / 6); // sin(π/6) = 0.5

生成一个随机数x，x的范围是0 <= x < 1：

Math.random(); // 0.53907... 每次都不一样

包装类型

  • int—————————->Integer
  • short————————->Short
  • long—————————>Long
  • byte—————————>Byte
  • float————————–>Float
  • double————————>Double
  • char—————————–>Character
  • boolean————————>Boolean

自动装箱和自动拆箱

  • 装箱:基本数据类型->包装类对象
new Integer(2);
  • 拆箱:包装类对象->基本数据类型
Integer k = new Integer(1); int y = k.intValue();
  • 自动装箱
Integer j=1;
  • 自动拆箱
int i=new Integer(2);

java.lang.System

// getProperty(String)方法使用的当前系统属性集作为一个properties对象返回 Properties properties=System.getProperties(); for (Object key :		 properties.keySet()) {		 System.out.println(key+":"+properties.getProperty(String.valueOf(key))); }// System.currentTimeMillis()返回当前时间的毫秒数 System.out.println(System.currentTimeMillis());// System.nanoTime()返回正在运行的Java虚拟机的高精确率时间源的当前值，以纳秒为单位 System.out.println(System.nanoTime());// 终止当前运行的Java虚拟机 System.exit(1);// 运行垃圾收集器 System.gc();// 数组复制，调用系统接口 src:源数组； srcPos:源数组要复制的起始位置； dest:目的数组； destPos:目的数组放置的起始位置； length:复制的长度 System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)// 标准的输出流 System.out.println("12313");

异常处理

异常与错误

异常是由于程序代码的问题所产生的,当发生异常后,JVM会产生一个异常对象,如果不对异常进行处理,程序会终止执行,JVM会异常退出.java语言每种异常都有个名字,即异常类,所有异常类都继承java.lang.Exception

错误是由硬件设备所导致的,是应用程序不应该试图捕获的严重问题.java语言中每种错误都有个名字,即错误类,所有错误类都继承java.lang.Error.

如:java.lang.StackOverflowError:堆栈溢出错误，用程序递归太深而发生堆栈溢出时,抛出该错误.

public static void main(String[] args) {    test();}public static void test() {    test();}

如:java.lang.OutOfMemoryError:内存溢出或没有可用的内存时,抛出该错误

public static void main(String[] args) {    //Requested array size exceeds VM limit    int i[] = new int[0x7fffffff];}

异常和错误关系

  • 异常属于应用程序级别的,程序员需要进行处理
  • 错误属于系统级别的,是应用程序不应该试图捕获的严重问题,程序员无需处理
  • 异常父类(java.lang.Exception)和错误父类(java.lang.Error)都继承于java.lang.Throwable

CheckedException

处理(必须要处理）

  • 使用try… catch
  • 在方法声明上throws Exception1,…（throws是指,如果当前方法里面有定义的throws Exception,就直接抛给调用者。如果调用了包括checkedException的throws语句的方法，这个时候，调用的地方也要处理。）

RuntimeException

常见的RuntimeException

算术异常:ArithmeticException

空指针异常:NullPointerException

数组索引下标越界异常:ArrayIndexOutOfBoundsException

字符串索引下标越界异常:StringIndexOutOfBoundsException

Class类型转换错误异常:ClassCastException

//算术异常:ArithmeticException//int i=3/0;//空指针异常:NullPointerException//String str=null;//str.length();// int  [] i={ };//数组索引下标越界异常:ArrayIndexOutOfBoundsException//System.out.println(i[0]);//String str="abc";//字符串索引下标越界异常:StringIndexOutOfBoundsException//str.charAt(3);//Class类型转换错误异常:ClassCastException//Object  ob=new Integer(3);//String  str=(String)ob;

捕获异常(try-catch-finally)

try {    int [] i={};    System.out.println(i[0]);    System.out.println("未发生异常");}catch (NullPointerException e) {    System.out.println("发生空指针异常");} catch (ArithmeticException e) {    System.out.println("发生算术异常");}finally{    //不管有没有发生异常,都需要执行    System.out.println("finally");}System.out.println("main end");/**只有与finally对应的try语句块得到执行的情况下，finally语句块才会执行。--如果代码中执行了if语句那么finally不会执行--如果i/0不被注释那么finally也不会执行--如果主动调用system.exit(0)退出JVM，那么finally也不会执行--finally代码块中使用return那么运行结果一定是finally中的返回值--finally代码块中只赋值不return不影响最终运行结果**/public class FinallyDemo {    public static void main(String[] args) {        int i = test();        System.out.println(i);    }    private static int test() {        int i=1;        //  if(i==1){        //  return 0;        // }        // i = i/0;        try {            System.out.println("try");            System.exit(0);            return i;        }catch (Exception e){            System.out.println("cache");            return i;        }finally {            System.out.println("finally");            //return 666;            i=666;        }    }    }

抛出异常

向方法体外抛出异常

public static void method1(String text) throws ParseException, SQLException {    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-DD");    Date date = sdf.parse(text);    System.out.println(date);    DriverManager.getConnection("","","");}public static void method2(String text) throws ParseException, SQLException {    method1(text);}public static void main(String[] args) throws ParseException , SQLException{    String text = "2019-09-01";    method2(text);    System.out.println("main end");}

手动抛出异常

代码语法没有错误,但不符合业务逻辑设计.例如: 用int类型表示性别状态,1:男;2:女,当出现1和2意外的数字时,就违反了业务逻辑设计.如果程序继续运行下去,可能会导致更大的业务逻辑错误,这时候,程序员可以手动抛出异常,阻止业务方法继续执行.

 * 根据性别状态打印性别名称 * @param sex */public static  void  showSexName(int sex){    if(1==sex){        System.out.println("男");    }else if(2==sex){        System.out.println("女");    }else{      //手动抛出异常        throw  new RuntimeException("性别错误");    }}

自定义异常

在一个大型项目中，可以自定义新的异常类型，但是，保持一个合理的异常继承体系是非常重要的。

一个常见的做法是自定义一个BaseException作为“根异常”，然后，派生出各种业务类型的异常。

BaseException需要从一个适合的Exception派生，通常建议从RuntimeException派生：

public class BaseException extends RuntimeException {
}

其他业务类型的异常就可以从BaseException派生：

public class UserNotFoundException extends BaseException {
}

public class LoginFailedException extends BaseException {
}
...

自定义的BaseException应该提供多个构造方法：

public class BaseException extends RuntimeException {
    public BaseException() {
        super();
    }

    public BaseException(String message, Throwable cause) {
        super(message, cause);
    }

    public BaseException(String message) {
        super(message);
    }

    public BaseException(Throwable cause) {
        super(cause);
    }
}

Java.util学习笔记

java.util.Date

Date date=new Date();
System.out.println(date);
//获取日期对象的毫秒数
long time=  date.getTime();
int year=  1900+ date.getYear();//获取年
System.out.println(year);
int month=date.getMonth()+1;//获取月0-11
System.out.println(month);
//获取周中的天 0-6
int dayInWeek=date.getDay();
System.out.println(dayInWeek);

java.util.Calendar

package cn.zys1314.javase.util;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Random;

public class CalendarTest {
	public static void main(String[] args) throws ParseException {
		Calendar ca = Calendar.getInstance();
		System.out.println(ca.get(Calendar.YEAR));
		// 每个星期的第几天 星期天是第一天
		System.out.println(ca.get(Calendar.DAY_OF_WEEK));
		System.out.println(ca.get(Calendar.WEEK_OF_MONTH));
		System.out.println(ca.get(Calendar.WEEK_OF_YEAR));
		ca.set(Calendar.WEEK_OF_YEAR, 1);
		System.out.println(ca.get(Calendar.WEEK_OF_YEAR));
		System.out.println(ca.get(Calendar.MONTH));
		ca.add(Calendar.MONTH, -2);
		System.out.println(ca.get(Calendar.MONTH));
		System.out.println("------------------------------------------");
		// date String
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日hh时mm分ss秒");
		Date date = new Date();
		System.out.println(sdf.format(date));
		String string = "2020年12月19日14时52分30秒";
		Date date2 = sdf.parse(string);
		System.out.println(date2);
	}
}
package cn.zys1314.javase.util;

import java.util.Calendar;

public class PrintDays {
        /**根据年、月打印本月所有的日期
         * 要点:
         *   1.根据年、月确定本月天数
         *   2.本月第一天周中的天
         *   3.每行打印7个日期,当打印到第一天或最后一天换行
         * @param year  年
         * @param month  月
         */
        public static void printOneMonth(int year, int month) {
            Calendar c=Calendar.getInstance();
            c.set(year,month-1,1);
            //获取本月共有多少天
            int days=c.getActualMaximum(Calendar.DAY_OF_MONTH);
            //获取本月第1天周中的天
            int dayOfWeek=c.get(Calendar.DAY_OF_WEEK);//1-7
            System.out.println("日\t一\t二\t三\t四\t五\t六");
            //打印本月第1天前面的空格
            int b=dayOfWeek-1;
            for(int i=1;i<=b;i++){
                System.out.print(' ');
                System.out.print('\t');
            }
            //打印本月的所有日期
            for(int d=1;d<=days;d++){
                System.out.print(d);
                System.out.print('\t');
                if(7==dayOfWeek){
                    System.out.println();
                    dayOfWeek=1;
                }else{
                    dayOfWeek++;
                }
            }
        
        public static void main(String[] args) {
            printOneMonth(2020,12);
        }
    }

java.util.Random

      Random random = new Random();
for (int i = 0; i < 8; i++) {
	int type = random.nextInt(3);
	char ch = '\0';
	switch (type) {
	case 0:
		ch = (char) (random.nextInt(26) + 65);
		break;
	case 1:
		ch = (char) (random.nextInt(26) + 97);
		break;
	case 2:
		ch = (char)(random.nextInt(10)+'0');
		break;
	default:
		break;
	}
	System.out.print(ch);
          }

java.util.Collection

Java标准库自带的java.util包提供了集合类：Collection，它是除Map外所有其他集合类的根接口。

集合类

ArrayList

List 接口的大小可变数组实现.允许包括null,包含重复元素

ArrayList：底层是动态数组、查找快增删慢， 默认初始容量是10、每次采用1.5倍的扩容。

//创建ArrayList对象
ArrayList<String> list = new ArrayList<>();
//添加对象
list.add("abc");//0
list.add("123");//1
list.add("你好");//2
list.add("abc");//3
//获取ArrayList的长度
int count= list.size();
System.out.println(count);
//获取ArrayList中的对象
System.out.println(list.get(1));
//list.remove("abc");
String str=list.remove(1);
System.out.println(str);
System.out.println(list);
//清空,及删除所有的对象
list.clear();
System.out.println(list);
list.add("baidu");
list.add("taobao");
list.add("jd");
//判断是否包含"taobao"
list.contains("taobao");
System.out.println(list.isEmpty());
list.clear();
System.out.println(list.isEmpty());
list.add("zhongshan");//0
list.add("shanghai");
list.add("beijing");
list.add("zhongshan");
list.add(null);
//查找是否包含某个对象
System.out.println(list.indexOf("zhongshan"));
System.out.println(list.lastIndexOf("zhongshan"));
//打印输出或得到ArrayList中所有的对象
int len=list.size();
for(int index=0;index<len;index++){
    System.out.println(list.get(index));
}
System.out.println("**************");
//forEach
for(String str1:list){
    System.out.println(str1);
}

Vector

Vector 实现方式与ArrayList相同,为大小可变的”动态数组”.

Vector与ArrayList区别:

1.Vector是线程同步的,即线程安全的;而Arraylist是线程非安全的.如果不考虑到线程的安全因素，一般用Arraylist效率比较高。

2.如果集合中的元素的数目大于目前集合数组的长度时，vector增长率为目前数组长度的100%,而Arraylist增长率为目前数组长度的50%.如果在集合中使用数据量比较大的数据，用Vector有一定的优势。

Stack

Stack 类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法

LinkedList

List 接口的双向链表实现,允许包含null,包含重复元素.此外,LinkedList还实现 Deque 接口，提供先进先出队列操作，以及其他堆栈和双端队列操作

//LinkedList基本使用
List<String>  list=new LinkedList<>();
//向链表中添加对象
list.add("abc");
list.add("123");
list.add("tom");
System.out.println(list);
System.out.println( list.get(1));
list.remove(1);
int size=list.size();
//清空
list.clear();
//包含
list.contains("abc");
//双向链表 LinkedList实现栈的特点
LinkedList<String> stack = new LinkedList<>();
//将对象添加到栈中,即压入到栈底
stack.push("123");
stack.push("abc");
stack.push("tom");
stack.push(null);
//查看栈顶的对象或数据
//System.out.println(stack.peek());
while(!stack.isEmpty()){
    //移除栈顶的对象
    String str=stack.pop();
    System.out.println(str);
}        
//双向链表 LinkedList实现队列的特点
LinkedList<String> deque = new LinkedList<>();
//将对象或数据加入队列:入队
 deque.offer("123");
 deque.offer("abc");
 deque.offer("tom");
 System.out.println(deque);
 while(!deque.isEmpty()){
     //移除队列中第一个对象 ,即出队
     String str=deque.poll();
     System.out.println(str);
 }

HashMap

基于哈希表的 Map接口的实现 .提供所有可选的映射操作 , 并允许使用 null 值和 null 键,不保证映射的顺序(除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 相同)

底层是数组+链表+红黑树，默认初始容量是16、扩容因子为0.75，每次采用2倍的扩容

//创建哈希表
Map<String, String> userMap = new HashMap<>();
//添加key->value
userMap.put("xiaoming", "小明");
userMap.put("tom", "汤姆");
userMap.put("cat", "猫V1.0");
//根据key获取value
System.out.println(userMap.get("xiaoming"));
//获取键值对数量
int count = userMap.size();
System.out.println(count);
System.out.println(userMap);
userMap.put("cat", "猫V2.0");
System.out.println(userMap);
//删除键值对
userMap.remove("cat");
System.out.println(userMap);
//清空所有键值对
userMap.clear();
System.out.println(userMap);
//判断哈希表是否为空,即不包含任何的键值对
userMap.isEmpty();

userMap.put(null, null);

Map<String, Student> stuMap = new HashMap<>();
stuMap.put("S001", new Student("S001", "学生1", 1, new Date()));
stuMap.put("S002", new Student("S002", "学生1", 1, new Date()));
//stuMap.put("S003", new Student("S003", "学生1", 1, new Date()));
stuMap.put("S004", new Student("S004", "学生1", 1, new Date()));
stuMap.put("S005", new Student("S005", "学生1", 1, new Date()));
Student stu = stuMap.get("S003");
if (stu == null) {
    System.out.println("未查找到S003的学生");
} else {
    System.out.println(stu);
}

Hashtable

此类实现一个哈希表 ,该哈希表将键映射到相应的值 ,任何非 null 对象都可以用作键或值 .

Hashtable与HashMap的区别

HashMap HashTable
线程安全 非线程安全 线程安全
底层数据结构 Object数组+链表+红黑树 Object数组+链表
Null支持 Key和Value都可以取Null值 Key不可以取Null值
初始容量和扩容 默认容量是16,扩容为2N 默认初始容量是11，扩容为2N+1
效率 效率高 效率低、已经弃用

TreeMap

基于红黑树 (Red -Black tree)NavigableMap 实现 .该映射根据其键的自然顺序进行排序或者根据创建映射时提供的 Comparator 进行排序 .

要点:

  1. 实现不是同步的
  2. 不允许null的key,但允许null的value

Set

Set集合的特点就是无序，不可重复，对比List集合是有序的，可以重复。

  • HashSet：HashSet的底层其实就是一个HashMap，
    只是我们add的时候只使用了HashMap的key部分。

  • TreeSet：可以对Set集合进行排序，默认自然排序。
    Set接口常见的实现类有哪些？

  • TreeSet存放自定义类型如何实现有序的？

    分别是采用Comparable接口和Comparator来实现

java.util.Iterator

package cn.zys1314.javase.util;

import java.util.ArrayList;
import java.util.Iterator;

public class IterableTest {
	
/**
 * 1.要获得Iterator对象，就要实现Iterable接口，重写iteator()方法;
 * 2.集合调用iterator方法获取Iterator对象，这个迭代器对象是绑定在这个集合对象上
 * 3.调用Iterator的hasNext()方法，判断是否还有下一个元素存在
 * 4.调用Iterator.next(),获取下一个元素
 * 5.迭代器用完之后(Iterator到达集合的末尾),这个迭代器就作废了 
 * 6.如果需要重新迭代集合,需要重新调用集合的iterator()方法返回对应的Iterator对象
 * 7.在迭代的过程中是不能调用Collection的remove()方法来删除元素的;
 * 8.如果需要删除元素，需要调用Iteration的默认实现的remove()方法,remove()方法删除的对象是当前Iterator指向的元素
 * 9.要实现Iterable接口才能使用for-each-Loop                                    
 */

	public static void main(String[] args) {
		
		ArrayList list =new ArrayList();
		for (int i = 0; i < 10; i++) {
			list.add(i);
		}
	
		Iterator iterable=list.iterator();
		while (iterable.hasNext()) {
			Object object=iterable.next();
			if(object.equals(5)) {
				//list.remove(object);
				iterable.remove(); 
			}
			System.out.println(object); 
		}
		System.out.println("===========");
		 iterable=list.iterator();
		while (iterable.hasNext()) {
			Object object=iterable.next();
			System.out.println(object); 			
		}	
	}
}

手写简化版LinkedList

package test.day04;

import java.util.Iterator;

public class MylinkedList implements Iterable {

	private int size;

	private Node first;

	private Node last;

	public void addFirst(Object e) {
		Node head = first;
		Node newNode = new Node(e, null, head);
		first = newNode;
		if (head == null) {
			last = newNode;
		} else {
			head.prev = newNode;
		}
		size++;
	}

	public void addLast(Object e) {
		Node tail = last;
		Node newNode = new Node(e, tail, null);
		last = newNode;
		if (last == null) {
			first = newNode;
		} else {
			tail.next = newNode;
		}
		size++;
	}

	public void add(int index, Object e) {
		if (index < 0 || index > size) {
			throw new NullPointerException();
		}
		if (index == 0) {
			addFirst(e);
		} else if (index == size) {
			addLast(e);
		} else {
			Node temp = first;
			for (int i = 0; i < index; i++) {
				temp = temp.next;
			}
			Node newNode = new Node(e, temp.prev, temp);
			temp.prev.next = newNode;
			temp.prev = newNode;
			size++;
		}
	}

	public int indexof(Object o) {
		Node node = first;
		int count = 0;
		while (node!= null) {
			if (o.equals(node.value)) {
				return count;
			}
			count++;
			node = node.next;
		}
		return -1;
	}
	
	public int lastIndexof(Object o) {
		Node node = last;
		int count = 0;
		while (node!= null) {
			count++;
			if (o.equals(node.value)) {
				return size-count;
			}
			node = node.prev;
		}
		return -1;
	}

	public Object get(int index) {
		if (index < 0 || index >= size) {
			throw new NullPointerException();
		}
		Node newNode = first;
		for (int i = 0; i < index; i++) {
			newNode = newNode.next;
		}
		return newNode;
	}

	public void set(int index, Object e) {
		if (index < 0 || index >= size) {
			throw new NullPointerException();
		}
		Node temp = first;
		for (int i = 0; i < index; i++) {
			temp = temp.next;
		}
		temp.value = e;
	}

	public Object getFirst() {
		if (first == null) {
			throw new NullPointerException();
		}
		return first;
	}

	public Object getLast() {
		if (last == null) {
			throw new NullPointerException();
		}
		return last;
	}

	public Object removeFirst() {
		if (first == null) {
			throw new NullPointerException();
		}
		Node newNode = first;
		first = newNode.next;
		newNode.next.prev = null;
		size--;
		return newNode;
	}

	public Object removeLast() {
		if (last == null) {
			throw new NullPointerException();
		}
		Node newNode = last;
		last = newNode.prev;
		last.next = null;
		newNode.prev = null;
		size--;
		return newNode;
	}

	public Object remove(int index) {
		if (index < 0 || index >= size) {
			throw new IndexOutOfBoundsException(index + "");
		}
		Node newNode = first;
		if (index == 0) {
			newNode = (Node) removeFirst();
		} else if (index == size - 1) {
			newNode = (Node) removeLast();
		} else {
			for (int i = 0; i < index; i++) {
				newNode = newNode.next;
			}
			newNode.prev.next = newNode.next;
			newNode.next.prev = newNode.prev;
			size--;
		}
		return newNode;
	}
	
	public int size() {
		return size;
	}

	public static class Node {
		private Object value;
		private Node prev;
		private Node next;

		public Node(Object value, Node prev, Node next) {
			this.value = value;
			this.prev = prev;
			this.next = next;
		}

		 @Override
		public String toString() {
			return "" + value;
		}

	}

	@Override
	public Iterator iterator() {
		
		return new Iterator() {
			
			private int currentIndex=0;

			@Override
			public boolean hasNext() {
				if (currentIndex>=size) {
					return false;
				}
				return true;
			}

			@Override
			public Object next() {
				
				return get(currentIndex++);
			}
			
		};
	}
}

正则表达式学习笔记

使用正则表达式的好处

一个正则表达式就是一个描述规则的字符串，所以，只需要编写正确的规则，我们就可以让正则表达式引擎去判断目标字符串是否符合规则。

正则表达式是一套标准，它可以用于任何语言。Java标准库的java.util.regex包内置了正则表达式引擎，在Java程序中使用正则表达式非常简单。

java.util.regex

主要包括以下三个类：

  • Pattern 类：

    pattern 对象是一个正则表达式的编译表示。Pattern 类没有公共构造方法。要创建一个 Pattern 对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。该方法接受一个正则表达式作为它的第一个参数。

  • Matcher 类：

    Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern 类一样，Matcher 也没有公共构造方法。你需要调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。

  • PatternSyntaxException：

    PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

匹配规则

如果正则表达式有特殊字符，那就需要用\转义。

要注意正则表达式在Java代码中也是一个字符串，所以，对于正则表达式\\反斜杠来说，对应的Java字符串是"\\\\"，因为\也是Java字符串的转义字符，两个\\实际上表示的是一个\。

表达式 含义
[abc] a,b,c中的一个字符（[]匹配中括号内的一个字符）
[^abc] 除a,b,c以外的任意一个字符
[A-a] A-a中的一个字符(区间根据字符编码的大小,右边的编码要大于左边的编码）
[A-z&&[^abc]] A-a中并且除了abc的一个字符(区间根据字符编码的大小,右边的编码要大于左边的编码）
\\ 反斜杠 \
\d 一个0-9的数字
\D 一个非0-9的字符
\s 一个空白字符
\S 一个非空白字符
\w 一个字母、数字或下划线
. 一个任意字符
^ 一行的开始
$ 一行的结束
X? X出现0次或一次
X* X出现任意次
X+ X出现至少一次
X{n} X出现n次
X{n,} X出现至少n次
X{n,m} X至少出现n次但不超过m次

分组匹配

用Pattern对象匹配，匹配后获得一个Matcher对象，如果匹配成功，就可以直接从Matcher.group(index)返回子串。

public static void main(String[] args) {
        Pattern p = Pattern.compile("(\\d{3,4})\\-(\\d{7,8})");
        Matcher m = p.matcher("0731-12345678");
        if (m.matches()) {
            String g1 = m.group(1);
            String g2 = m.group(2);
            System.out.println(g1);
            System.out.println(g2);
            System.out.println(m.group());  
        } else {
            System.out.println("匹配失败!");
        }
    }
/** 运行结果
 * 0731
 * 12345678
 * 0731-12345678
**/

贪婪匹配

先看看整个字符串是否存在匹配，如果未发现匹配，则去掉字符串中的最后一个字符，再次尝试匹配，如果还是未发现匹配再去掉最后一个字符，循环往复直到发现一个匹配或者字符串不剩任何字符串。

/** 贪婪匹配 **/
public class Main {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("(\\d+)(0*)");
        Matcher matcher = pattern.matcher("1230000");
        if (matcher.matches()) {
            System.out.println("group1=" + matcher.group(1)); // "1230000"
            System.out.println("group2=" + matcher.group(2)); // ""
        }
    }
}

惰性匹配

先看看字符串的第一个字母是否存在匹配，如果未发现匹配，则读入下一个字符，再次尝试匹配，如果还是未发现匹配则再读取下一个字符，循环往复直到发现一个匹配或者整个字符串都检查过也没有发现匹配。

给定一个匹配规则，加上?后就变成了惰性匹配。

/** 惰性匹配 **/
public class Main {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("(\\d+?)(0*)");
        Matcher matcher = pattern.matcher("1230000");
        if (matcher.matches()) {
            System.out.println("group1=" + matcher.group(1)); // "123"
            System.out.println("group2=" + matcher.group(2)); // "0000"
        }
    }
}

支配匹配

只尝试匹配整个字符串。如果整个字符串不匹配，则不做进一步。

给定一个匹配规则，加上+后就变成了支配匹配。

/** 支配 **/
public class Main {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("(\\d++)(0*)");
        Matcher matcher = pattern.matcher("1230000");
        if (matcher.matches()) {
            System.out.println("group1=" + matcher.group(1)); // "1230000"
            System.out.println("group2=" + matcher.group(2)); // ""
        }
    }
}

泛型学习笔记

泛型就是编写模板代码来适应任意类型；

泛型的好处是使用时不必对类型进行强制转换，它通过编译器对类型进行检查；

泛型的使用

使用ArrayList时，如果不定义泛型类型时，泛型类型实际上就是Object

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
// 编译器警告:
List list = new ArrayList();
list.add("Hello");
list.add("World");
String first = (String) list.get(0);
String second = (String) list.get(1);
// 无编译器警告:
List<String> list = new ArrayList<String>();
list.add("Hello");
list.add("World");
// 无强制转型:
String first = list.get(0);
String second = list.get(1);

extends

Pair不是Pair的子类;

使用的泛型定义称之为上界通配符（Upper Bounds Wildcards），即把泛型类型T的上界限定在Number了。

使用类似通配符作为方法参数时表示：

  • 方法内部可以调用获取Number引用的方法，例如：Number n = obj.getFirst();；
  • 方法内部无法调用传入Number引用的方法（null除外），例如：obj.setFirst(Number n);。

即一句话总结：使用extends通配符表示可以读，不能写。

使用类似定义泛型类时表示：

  • 泛型类型限定为Number以及Number的子类。

super

Pair表示，方法参数接受所有泛型类型为Integer或Integer父类的Pair类型。

使用类似通配符作为方法参数时表示：

  • 方法内部可以调用传入Integer引用的方法，例如：obj.setFirst(Integer n);；
  • 方法内部无法调用获取Integer引用的方法（Object除外），例如：Integer n = obj.getFirst();。

即使用super通配符表示只能写不能读。

使用extends和super通配符要遵循PECS原则。

无限定通配符很少使用，可以用替换，同时它是所有类型的超类。

PECS原则

何时使用extends，何时使用super？为了便于记忆，我们可以用PECS原则：Producer Extends Consumer Super。

即：如果需要返回T，它是生产者（Producer），要使用extends通配符；如果需要写入T，它是消费者（Consumer），要使用super通配符。

还是以Collections的copy()方法为例：

public class Collections {
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        for (int i=0; i<src.size(); i++) {
            T t = src.get(i); // src是producer
            dest.add(t); // dest是consumer
        }
    }
}

对比extends和super通配符

我们再回顾一下extends通配符。作为方法参数，类型和类型的区别在于：

  • 允许调用读方法T get()获取T的引用，但不允许调用写方法set(T)传入T的引用（传入null除外）；
  • 允许调用写方法set(T)传入T的引用，但不允许调用读方法T get()获取T的引用（获取Object除外）。

一个是允许读不允许写，另一个是允许写不允许读。

Java.io学习笔记

File

File对象既可以表示文件，也可以表示目录。特别要注意的是，构造一个File对象，即使传入的文件或目录不存在，代码也不会出错，因为构造一个File对象，并不会导致任何磁盘操作。只有当我们调用File对象的某些方法的时候，才真正进行磁盘操作。

public static void main(String[] args) throws Exception {
		File f=new File("/home/zengyusheng");
		//Arrays.asList(f.listFiles()).forEach(System.out::println);
		File[] fList=f.listFiles();
		for (File file : fList) {
//			if (file.getName().endsWith("h")) {
//				System.out.println(file.getName());
//			}
//			if (file.isDirectory()) {
//				System.out.println(file.getName());
//			}
//			if (file.isFile()) {
//				System.out.println(file);
//			}
//			if (file.isHidden()) {
//				System.out.println(file);
//			}
//			Path p1= Paths.get(".","study","test");
//			Path p2= p1.toAbsolutePath();
//			System.out.println(p2);
//			Path p3=p2.normalize();
//			System.out.println(p3);
//			File file2=p3.toFile();
//			System.out.println(file2);
			System.out.println(file.getAbsolutePath());
		    System.out.print(file.getName()+"\t"+new Date(file.lastModified()));
			if (file.isDirectory()) {
				
			}else {
				System.out.print("\t"+file.length()+" byte");
			}
			System.out.println();
		}
	}

public static void main(String[] args) {
		File file=new File("/home/zengyusheng/Desktop/zys/abc/a.txt");
		if (file.exists()) {
			file.delete();
		}else {
			try {
				File file2=file.getParentFile();
				if (!file2.exists()) {
					//file2.mkdir();
					file2.mkdirs();
				}
				file.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}                                                    
	}

InputStream

InputStream就是Java标准库提供的最基本的输入流。它位于java.io这个包里。java.io包提供了所有同步IO的功能。

要特别注意的一点是，InputStream并不是一个接口，而是一个抽象类，它是所有输入流的超类。这个抽象类定义的一个最重要的方法就是int read()，签名如下：

public abstract int read() throws IOException;

这个方法会读取输入流的下一个字节，并返回字节表示的int值（0~255）。如果已读到末尾，返回-1表示不能继续读取了。此方法阻塞，直到输入数据可用、检测到流的末尾或抛出异常为止。

FileInputStream

FileInputStream in = null;
try {
    //创建文件字节输入流对象
    in = new FileInputStream("D:\\test\\test01\\1.txt");
    //从文件读取一个字节
   /* while (true) {
        int i = in.read();
        //当读取到文件末尾时,退出循环
        if (-1 == i) {
            break;
        }
        System.out.print((char)i);
    }*/
    //从文件中一次读取多个字节
    byte[] bs = new byte[512];
    while (true) {
        int count = in.read(bs);
        if (-1 == count) {
            break;
        }
        //利用实际读取到的字节构造字符串
        //String str=new String(bs); 错误
        String str = new String(bs, 0, count);
        System.out.println(str);
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
} catch (Exception e) {
    e.printStackTrace();
}
if (in != null) {
    try {
        //关闭文件字符输入流
        in.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

OutputStream

FileOutputStream

和InputStream相反，OutputStream是Java标准库提供的最基本的输出流。

和InputStream类似，OutputStream也是抽象类，它是所有输出流的超类。这个抽象类定义的一个最重要的方法就是void write(int b)，签名如下：

public abstract void write(int b) throws IOException;

这个方法会写入一个字节到输出流。要注意的是，虽然传入的是int参数，但只会写入一个字节，即只写入int最低8位表示字节的部分（相当于b & 0xff）。

和InputStream类似，OutputStream也提供了close()方法关闭输出流，以便释放系统资源。要特别注意：OutputStream还提供了一个flush()方法，它的目的是将缓冲区的内容真正输出到目的地。

为什么要有flush()？因为向磁盘、网络写入数据的时候，出于效率的考虑，操作系统并不是输出一个字节就立刻写入到文件或者发送到网络，而是把输出的字节先放到内存的一个缓冲区里（本质上就是一个byte[]数组），等到缓冲区写满了，再一次性写入文件或者网络。对于很多IO设备来说，一次写一个字节和一次写1000个字节，花费的时间几乎是完全一样的，所以OutputStream有个flush()方法，能强制把缓冲区内容输出。

通常情况下，我们不需要调用这个flush()方法，因为缓冲区写满了OutputStream会自动调用它，并且，在调用close()方法关闭OutputStream之前，也会自动调用flush()方法。

FileOutputStream out = null;
     try {
         //创建文件字节输出流对象.true表示将内容写到文件末尾,不会覆盖文件原来的内容
         out = new FileOutputStream("D:\\test\\test01\\2.txt", true);
         //写一个字节
         out.write('a');
         out.write('\t');
         //写多个字节
         String baidu = "https://www.baidu.com";
         out.write(baidu.getBytes());
         //写回车换行符
         out.write("\r\n".getBytes());
     } catch (Exception e) {
         e.printStackTrace();
     }
     //关闭
     if (out != null) {
         try {
             out.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

带缓冲的字节输入流、输出流

/**
 * 拷贝图片
 */
public class CopyImg {

    /**
     * 将指定路径的图片复制到指定的文件夹中去
     *
     * @param imgPath
     * @param destDirPath
     */
    public final static void copyImg(String imgPath, String destDirPath) {
        File imgFile = new File(imgPath);
        if (!imgFile.isFile()) {
            throw new IllegalArgumentException(imgPath + "不存在!");
        }
        File destDir = new File(destDirPath);
        if (!destDir.isDirectory()) {
            throw new IllegalArgumentException(destDirPath + "不存在!");
        }
        //拷贝图片
        FileInputStream in = null;
        FileOutputStream out = null;
        BufferedInputStream bufInput = null;
        BufferedOutputStream bufOutput = null;
        try {
            in = new FileInputStream(imgFile);//从"旧"图片文件,即源文件中读取字节
            //创建带有缓冲区的字节输入流
            bufInput = new BufferedInputStream(in);
            //创建"新"图片文件,即备份文件
            File newImg = new File(destDirPath, imgFile.getName());
            if (!newImg.exists()) {
                newImg.createNewFile();
            }
            out = new FileOutputStream(newImg);//向"新"图片文件,即备份文件中写字节
            //创建带有缓冲区的字节输出流
            bufOutput=new BufferedOutputStream(out);
            byte[] bs = new byte[1024];
            while (true) {
                //从"旧"图片中读取字节
                int count = bufInput.read(bs);
                if (-1 == count) {
                    break;
                }
                //将读取到的字节写到"新"图片文件中
                bufOutput.write(bs, 0, count);
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        //关闭
        if (bufInput != null) {
            try {
                bufInput.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (bufOutput != null) {
            try {
                bufOutput.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args) {
        copyImg("C:\\Users\\luliujun\\Pictures\\class文件执行简单原理.png", "D:\\test\\test01");
    }
}

文件和文件夹的复制

public class FileCopyAllTest {

	public static void main(String[] args) throws Exception {
		copyFile("/home/zengyusheng/Desktop/zys", "/home/zengyusheng/Desktop/a/b");
	}

	public static void copyFile(String files, String path) throws Exception {

		File file1 = new File(files);
		String filename = null;
		if (file1.isFile()) {
			filename = file1.getName();
			//System.out.println(filename);
			InputStream in = new FileInputStream(file1);
			File file2 = new File(path + "/" + filename);
			if (!file2.getParentFile().exists()) {
				file2.getParentFile().mkdirs();
			}
			file2.createNewFile();
			OutputStream out = new FileOutputStream(file2);
			byte[] chs = new byte[100];
			while (true) {
				int count = in.read(chs);
				if (count == -1) {
					break;
				}
				out.write(chs, 0, count);
			}
			if (in != null) {
				in.close();
			}
			if (out != null) {
				out.close();
			}
		} else {
			copyDirectory(file1, path + "/" + file1.getName());
		}
	}

	public static void copyDirectory(File files, String path) throws Exception {
		File directory = new File(path);
		if(!directory.exists()) {
			directory.mkdirs();
		}
		for (File file : files.listFiles()) {
			copyFile(file.getAbsolutePath(), path);
			System.out.println(file);
		}
	}
}

DataOutputStream

public static void main(String[] args) throws Exception {
		FileOutputStream fos =new FileOutputStream("./aa.txt");
		DataOutputStream doStream=new DataOutputStream(fos);
		doStream.writeDouble(123.45);
		doStream.writeBoolean(false);
		doStream.writeInt(15);
		//doStream.writeChars("hello world !");
		doStream.write(5);
		doStream.close();
		fos.close();
	}

DataInputStream

数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。

FileInputStream fos =new FileInputStream("./aa.txt");		DataInputStream dis   =new DataInputStream(fos);        System.out.println(dis.readDouble());        System.out.println(dis.readBoolean());        System.out.println(dis.readInt());//        System.out.println(dis.readByte());//        System.out.println(dis.readByte());//        System.out.println(dis.readByte());//        System.out.println(dis.readByte());//        System.out.println(dis.readChar());        System.out.println(dis.read());        dis.close();	}

序列化

序列化是指把一个Java对象变成二进制内容，本质上就是一个byte[]数组。

为什么要把Java对象序列化呢？因为序列化后可以把byte[]保存到文件中，或者把byte[]通过网络传输到远程，这样，就相当于把Java对象存储到文件或者通过网络传输出去了。

有序列化，就有反序列化，即把一个二进制内容（也就是byte[]数组）变回Java对象。有了反序列化，保存到文件中的byte[]数组又可以“变回”Java对象，或者从网络上读取byte[]并把它“变回”Java对象。

我们来看看如何把一个Java对象序列化。

一个Java对象要能序列化，必须实现一个特殊的java.io.Serializable接口，它的定义如下：

public interface Serializable {}

Serializable接口没有定义任何方法，它是一个空接口。我们把这样的空接口称为“标记接口”（Marker Interface），实现了标记接口的类仅仅是给自身贴了个“标记”，并没有增加任何方法。

ObjectOutputStream

public class Student implements Serializable {	
	private  int id;
	private String name;
	private int age;
	private boolean gender;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public boolean isGender() {
		return gender;
	}
	public void setGender(boolean gender) {
		this.gender = gender;
	}	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
}
public static void main(String[] args) throws Exception {
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./aa.txt"));
		Student student =new Student();
		student.setAge(18);
		student.setName("dasdasd");
		student.setGender(true);
		oos.writeObject(student);
		oos.close();
	}

ObjectInputStream

public static void main(String[] args)  throws Exception{
	ObjectInputStream obs =new ObjectInputStream(new FileInputStream("./aa.txt"));
	System.out.println(obs.readObject());
	obs.close();
	}

Reader

字符输入流

FileReader

public static void main(String[] args) {
       File txt = new File("D:\\test\\test01\\2.txt");
       FileReader reader = null;
       try {
           reader = new FileReader(txt);
           char [] chs=new char[500];
           while (true) {
               int count = reader.read(chs);
               if (-1 == count) {
                   break;
               }
               String str=new String(chs,0,count);
               System.out.println(str);

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

BufferReader

public class BufferedReaderDemo {
    public static void main(String[] args) {
        File txt = new File("D:\\test\\test01\\2.txt");
        FileReader reader = null;
        BufferedReader bufReader = null;
        try {
            reader = new FileReader(txt);
            //创建缓冲字符输入流对象
            bufReader = new BufferedReader(reader);
            char[] chs = new char[500];
            while (true) {
                //读取一行
                String line = bufReader.readLine();
                if (line == null) {
                    break;
                }
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (reader != null) {
            try {
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Writer

字节输出流

FileWriter

/**
 * 字符输出流,向文本文件打印本月日历
 */
public static void main(String[] args) {
        FileWriter writer = null;
        try {
            //writer = new FileWriter("D:\\test\\test01\\3.txt",true);
            writer = new FileWriter("D:\\test\\test01\\3.txt");
            Calendar c = Calendar.getInstance();
            //获取本月共有多少天
            int days = c.getActualMaximum(Calendar.DAY_OF_MONTH);
            //当天月中的天
            int date = c.get(Calendar.DAY_OF_MONTH);
            //获取本月第1天周中的天
            int dayOfWeek = c.get(Calendar.DAY_OF_WEEK);//1-7
            writer.write("日\t一\t二\t三\t四\t五\t六");
            writer.write("\r\n");
            //打印本月第1天前面的空格
            int b = dayOfWeek - 1;
            for (int i = 1; i <= b; i++) {
                writer.write(" \t");
            }
            //打印本月的所有日期
            for (int d = 1; d <= days; d++) {
                writer.write(String.valueOf(d));
                if (d == date) {
                    writer.write('*');
                }
                writer.write('\t');
                if (7 == dayOfWeek) {
                    writer.write("\r\n");
                    dayOfWeek = 1;
                } else {
                    dayOfWeek++;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (writer != null) {
            try {
                writer.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

BufferedWriter

public static void main(String[] args) {
       FileWriter writer = null;
       BufferedWriter bufWriter = null;
       try {
           writer = new FileWriter("D:\\test\\test01\\3.txt");
           /**
            * 创建缓冲字符输出流对象, 参数1024表示缓冲区大小,即缓冲区可以存放1024字符
            * 当缓冲区存满后,会自动刷新,即将缓冲区中所有数据写入文件中,重置缓冲区数据(将缓冲区char数组每个元素设置为'0')
            * 可以调用flush() 自动刷新
            */
           bufWriter = new BufferedWriter(writer, 1024);
           int rows = 19;//输出菱形总行数
           int bx = -rows / 2;//控制空格 变化的变量
           for (int r = 1; r <= rows; r++) {
               int b = Math.abs(bx);//每行输出空格数量
               for (int c = 1; c <= b; c++) {
                   bufWriter.write(' ');
               }
               int s = rows - 2 * b;//每行输出*数量
               for (int c = 1; c <= s; c++) {
                   bufWriter.write('*');
               }
               bx++;
               bufWriter.write("\r\n");//回车换行
           }

           //刷新缓冲区
           bufWriter.flush();

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

   }

标准流

  • System.out ：“标准”输出流
  • System.in：“标准”输入流
  • System.err：“标准”错误输出流
public class SystemStream {
    public static void main(String[] args) {
        InputStreamReader reader = null;
        BufferedReader bufReader = null;
        try {
            //基于"标准"输入流创建字符流
            reader = new InputStreamReader(System.in);
            bufReader = new BufferedReader(reader);
            System.out.println("请输出一句话:");
            while (true) {
                String line = bufReader.readLine();
                if (line == null ||0== line.length()) {
                    break;
                }
                System.out.println(line);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        if (bufReader != null) {
            try {
                bufReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
System.err.print("错误信息");

线程学习笔记

线程概念

进程

在计算机中，我们把一个任务称为一个进程，一个运行中的QQ就是一个进程。

线程

线程是进程的一个执行单位。

进程和线程

进程和线程是包含关系，但是多任务既可以由多进程实现，也可以由单进程内的多线程实现，还可以混合多进程＋多线程。

具体采用哪种方式，要考虑到进程和线程的特点。

和多线程相比，多进程的缺点在于：

  • 创建进程比创建线程开销大，尤其是在Windows系统上；
  • 进程间通信比线程间通信要慢，因为线程间通信就是读写同一个变量，速度很快。

而多进程的优点在于：

多进程稳定性比多线程高，因为在多进程的情况下，一个进程崩溃不会影响其他进程，而在多线程的情况下，任何一个线程崩溃会直接导致整个进程崩溃。

Java多线程

一个Java程序实际上是一个JVM进程，JVM进程用一个主线程来执行main()方法，在main()方法内部，我们又可以启动多个线程。此外，JVM还有负责垃圾回收的其他工作线程等。

线程的创建

1.通过继承Thread类，重写run()方法

public class Main {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start(); // 启动新线程
    }
}

class MyThread extends Thread {
    @Override
    public void run() 
        System.out.println("start new thread!");
    }
}

2.通过实现Runnable接口，创建线程实例时传入Runnable实例

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start(); // 启动新线程
    }
}

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("start new thread!");
    }
}
public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("start new thread!");
        });
        t.start(); // 启动新线程
    }
}

线程的状态

  1. 初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。

  2. 运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
    线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。

  3. 阻塞(BLOCKED)：表示线程阻塞于锁。

  4. 等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。

  5. 超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。

  6. 终止(TERMINATED)：表示该线程已终止。

    线程终止的原因有：

    • 线程正常终止：run()方法执行到return语句返回；
    • 线程意外终止：run()方法因为未捕获的异常导致线程终止；
    • 对某个线程的Thread实例调用stop()方法强制终止（强烈不推荐使用）。

线程的生命周期

线程的生命周期包含5个阶段，包括：新建、就绪、运行、阻塞、销毁。

  • 新建：就是刚使用new方法，new出来的线程；
  • 就绪：就是调用的线程的start()方法后，这时候线程处于等待CPU分配资源阶段，谁先抢的CPU资源，谁开始执行;
  • 运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run方法定义了线程的操作和功能;
  • 阻塞：在运行状态的时候，可能因为某些原因导致运行状态的线程变成了阻塞状态，比如sleep()、wait()之后线程就处于了阻塞状态，这个时候需要其他机制将处于阻塞状态的线程唤醒，比如调用notify或者notifyAll()方法。唤醒的线程不会立刻执行run方法，它们要再次等待CPU分配资源进入运行状态;
  • 销毁：如果线程正常执行完毕后或线程被提前强制性的终止或出现异常导致结束，那么线程就要被销毁，释放资源;

线程类的方法

设定线程的优先级（1-10），默认值5

setPriority(int newPriority)

使当前执行的线程在指定的毫秒数内休眠(临时停止执行)，这取决于系统计时器和调度程序的精度和准确性

sleep(long millis)

调度程序当前线程放弃对当前对处理器的使用

yield()

等待线程执行完

join()  //等待线程执行完
join(long millis) //等待多少毫秒
join(long millis, int nanos) //等待多少毫秒加多少纳秒

返回对当前正在执行的线程对象的引用

currentThread()

设置线程为守护线程(true)或用户线程`(false)

setDaemon(boolean on)

中断线程

在其他线程中对目标线程调用interrupt()方法，目标线程需要反复检测自身状态是否是interrupted状态，如果是，就立刻结束运行。

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new MyThread();
        t.start();
        Thread.sleep(1); // 暂停1毫秒
        t.interrupt(); // 中断t线程
        t.join(); // 等待t线程结束
        System.out.println("end");
    }
}

class MyThread extends Thread {
    public void run() {
        int n = 0;
        while (! isInterrupted()) {
            n ++;
            System.out.println(n + " hello!");
        }
    }
}

用一个running标志位来标识线程是否应该继续运行，在外部线程中，通过把HelloThread.running置为false，就可以让线程结束

public class Main {
    public static void main(String[] args)  throws InterruptedException {
        HelloThread t = new HelloThread();
        t.start();
        Thread.sleep(1);
        t.running = false; // 标志位置为false
    }
}

class HelloThread extends Thread {
//线程间共享变量需要使用volatile关键字标记，确保每个线程都能读取到更新后的变量值。
    public volatile boolean running = true;
    public void run() {
        int n = 0;
        while (running) {
            n ++;
            System.out.println(n + " hello!");
        }
        System.out.println("end!");
    }
}

为什么要对线程间共享的变量用关键字volatile声明？

在Java虚拟机中，变量的值保存在主内存中，但是，当线程访问变量时，它会先获取一个副本，并保存在自己的工作内存中。如果线程修改了变量的值，虚拟机会在某个时刻把修改后的值回写到主内存，但是，这个时间是不确定的！

volatile关键字的目的是告诉虚拟机：

  • 每次访问变量时，总是获取主内存的最新值；
  • 每次修改变量后，立刻回写到主内存。

守护线程

守护线程是指为其他线程服务的线程。在JVM中，所有非守护线程都执行完毕后，无论有没有守护线程，虚拟机都会自动退出。

如何创建守护线程呢？

调用setDaemon(true)把该线程标记为守护线程

Thread t = new MyThread();
t.setDaemon(true);

注意：守护线程不能持有任何需要关闭的资源，例如打开文件等，因为虚拟机退出时，守护线程没有任何机会来关闭文件，这会导致数据丢失。

线程同步

多个线程操作一个Java Heap 的对象

JVM规范定义了几种原子操作：

  • 基本类型（long和double除外）赋值，例如：int n = m；
  • 引用类型赋值，例如：List list = anotherList。

多线程同时读写共享变量时，会造成逻辑错误，因此需要通过synchronized同步；

同步的本质就是给指定对象加锁，加锁后才能继续执行后续代码；

注意加锁对象必须是同一个实例；

对JVM定义的单个原子操作不需要同步。

用synchronized修饰方法可以把整个方法变为同步代码块，synchronized方法加锁对象是this；

通过合理的设计和数据封装可以让一个类变为“线程安全”；

一个类没有特殊说明，默认不是thread-safe；

多线程能否安全访问某个非线程安全的实例，需要具体问题具体分析。

死锁

死锁产生的条件是多线程各自持有不同的锁，并互相试图获取对方已持有的锁，导致无限等待；

public class DeadLockTest {
	
	static StringBuffer sb1=new StringBuffer();
	static StringBuffer sb2=new StringBuffer();	
	
	public static void main(String[] args) {
		
		new Thread() {
			public void run() {
				synchronized(sb1) {
					try {
						Thread.sleep(20);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					sb1.append("A");
					synchronized (sb2) {
						sb2.append("B");
					}
				}
				System.out.println(sb1);
				System.out.println(sb2);
			};
		}.start();	
		
		new Thread() {
			public void run() {
				synchronized(sb2) {
					sb1.append("C");
					synchronized (sb1) {
						sb2.append("D");
					}
				}
				System.out.println(sb1);
				System.out.println(sb2);
			};
		}.start();	
		
	}
}

wait和notify

wait和notify用于多线程协调运行：

  • 在synchronized内部可以调用wait()使线程进入等待状态；
  • 必须在已获得的锁对象上调用wait()方法；
  • 在synchronized内部可以调用notify()或notifyAll()唤醒其他等待线程；
  • 必须在已获得的锁对象上调用notify()或notifyAll()方法；
  • 已唤醒的线程还需要重新获得锁后才能继续执行。

线程池

JDK提供了ExecutorService实现了线程池功能：

  • 线程池内部维护一组线程，可以高效执行大量小任务；
  • Executors提供了静态方法创建不同类型的ExecutorService；
  • 必须调用shutdown()关闭ExecutorService；
  • ScheduledThreadPool可以定期调度多个任务。

因为ExecutorService只是接口，Java标准库提供的几个常用实现类有：

  • FixedThreadPool：线程数固定的线程池；
  • CachedThreadPool：线程数根据任务动态调整的线程池；
  • SingleThreadExecutor：仅单线程执行的线程池。
public class ThreadPoolFinalTest {

	public static void main(String[] args) {

		ExecutorService pool = Executors.newFixedThreadPool(20);
		List<Future<Result>> results = new ArrayList<>();
		Map<Future<Result>,Task> futureTask=new HashMap<>();
		for (int i = 0; i < 20; i++) {
			Task task=new Task(i + 1);
			Future<Result> future = pool.submit(task);
			results.add(future);
			futureTask.put(future,task);
		}
		while(true){
			for (int i = 0; i < results.size(); i++) {
				Future<Result> future= future =results.get(i);
				if (future.isDone()){
					try {
						Result result = future.get();
						System.out.println(result);
					} catch (Throwable e) {
						System.err.println(e.getMessage());
						Task task=futureTask.get(future);
						Future<Result> future1=pool.submit(task);
						results.add(future1);
						futureTask.put(future1,task);
					}
					results.remove(i);
					i--;
				}
			}
			if (results.isEmpty()){
				break;
			}
		}
		pool.shutdown();
	}

	public static class Result {

		private int id;
		private String str;

		public Result(int id, String str) {
			this.id = id;
			this.str = str;
		}

		public int getId() {
			return id;
		}

		public void setId(int id) {
			this.id = id;
		}

		public String getStr() {
			return str;
		}

		public void setStr(String str) {
			this.str = str;
		}

		@Override
		public String toString() {
			return "Result [id=" + id + ", str=" + str + "]";
		}
	}

	private static class Task implements Callable<Result> {

		private Random random = new Random();
		private int id = -1;
		StringBuffer buffer = new StringBuffer();

		public Task(int id) {
			this.id = id;
		}

		@Override
		public Result call() throws Exception {

			for (int i = buffer.length(); i < 5; i++) {
				int type = random.nextInt(3);
				char ch = '\0';
				int bound = 0;
				switch (type) {
				case 0:
					bound = random.nextInt(9);
					break;
				case 1:
				case 2:
					bound = random.nextInt(26);
					break;
				}
				if (bound==0){
					throw  new RuntimeException("buffer:"+buffer+",bound:"+bound+",id:"+id);
				}
				switch (type) {
				case 0:
					ch = (char) (bound + '0');
					break;
				case 1:
					ch = (char) (bound + 'a');
					break;
				case 2:
					ch = (char) (bound + 'A');
					break;
				}
				buffer.append(ch);
			}
			try {
				int sleepTime = random.nextInt(15);
				System.out.println("sleeptime:" + sleepTime + ",id:" + id);
				Thread.sleep(sleepTime * 1000);
			} catch (Exception e) {

			}
			return new Result(this.id, buffer.toString());
		}
	}

}

xml学习笔记

XML是可扩展标记语言（eXtensible Markup Language）的缩写，它是是一种数据表示格式，可以描述非常复杂的数据结构，常用于传输和存储数据。

XML的结构

XML有固定的结构，首行必定是，可以加上可选的编码。紧接着，如果以类似声明的是文档定义类型（DTD：Document Type Definition），DTD是可选的。接下来是XML的文档内容，一个XML文档有且仅有一个根元素，根元素可以包含任意个子元素，元素可以包含属性，例如，1234567包含一个属性lang="CN"，且元素必须正确嵌套。如果是空元素，可以用表示

Dom

Java提供的DOM API可以将XML解析为DOM结构，以Document对象表示；

DOM可在内存中完整表示XML数据结构；

DOM解析速度慢，内存占用大。

public static void main(String[] args) throws Exception {
        DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
        DocumentBuilder documentBuilder=factory.newDocumentBuilder();
        File xml=new File("src/cn/zys1314/javase/xml/students.xml");
        Document document = documentBuilder.parse(xml);
        Element element = document.getDocumentElement();
        NodeList childNodes = element.getChildNodes();
        for (int i = 0; i <childNodes.getLength(); i++) {
            Node item = childNodes.item(i);
            //System.out.println(item);
            if (item instanceof Element){
                Element ele=(Element) item;
                System.out.println(ele.getNodeName());
                NodeList name = ele.getElementsByTagName("name");
                System.out.println(name.item(0).getTextContent());
            }
        }
    }

注解学习笔记

元注解

有一些注解可以修饰其他注解，这些注解就称为元注解（meta annotation）。Java标准库已经定义了一些元注解，我们只需要使用元注解，通常不需要自己去编写元注解。

@Target

最常用的元注解是@Target。使用@Target可以定义Annotation能够被应用于源码的哪些位置：

  • 类或接口：ElementType.TYPE；
  • 字段：ElementType.FIELD；
  • 方法：ElementType.METHOD；
  • 构造方法：ElementType.CONSTRUCTOR；
  • 方法参数：ElementType.PARAMET

@Retention

另一个重要的元注解@Retention定义了Annotation的生命周期：

  • 仅编译期：RetentionPolicy.SOURCE；
  • 仅class文件：RetentionPolicy.CLASS；
  • 运行期：RetentionPolicy.RUNTIME。

@Repeatable

使用@Repeatable这个元注解可以定义Annotation是否可重复。这个注解应用不是特别广泛。

@Inherited

使用@Inherited定义子类是否可继承父类定义的Annotation。@Inherited仅针对@Target(ElementType.TYPE)类型的annotation有效，并且仅针对class的继承，对interface的继承无效

注解的定义

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Auth {
    String value() default "";
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Component {
}

注解的处理和使用

可以在运行期通过反射读取RUNTIME类型的注解

可以通过程序处理注解来实现相应的功能

@Component
public class Component2 {
    @Auth
    public void test(){}
}
// 包扫描
public class PackageScan {
	public static void main(String[] args) {
		Class clazz = PackageScan.class;
		Package pkg = clazz.getPackage();
		String rootPkg = pkg.getName().split("\\.")[0];
		URL url = clazz.getResource("/" + rootPkg);
		String filePath = null;
		if (url.getProtocol().startsWith("file")) {
			filePath = url.getFile();
			File file = new File(filePath);
			printComponent(file, rootPkg);
		}
	}
	public static void printComponent(File file, String rootPkg) {
		File[] files = file.listFiles();
		for (File f : files) {

			if (f.isDirectory()) {
				printComponent(f, rootPkg + "." + f.getName());
			}
			if (f.isFile()) {
				if(f.getName().endsWith(".class")){
					String className = f.getName().substring(0, f.getName().lastIndexOf("."));
                    className=rootPkg + "." + className;
					try {
						Class cls=Class.forName(className);
						if (cls.isAnnotationPresent(Component.class)) {
							System.out.println(cls.getName());
						}
						Method[] methods = cls.getMethods();
						for (Method method:methods) {
							if (method.isAnnotationPresent(Auth.class))
							System.out.println(method);
						}
					} catch (ClassNotFoundException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}
}

JDBC学习笔记

JDBC简介

JDBC是Java DataBase Connectivity的缩写，它是Java程序访问数据库的标准接口。

使用JDBC的好处是：

  • 各数据库厂商使用相同的接口，Java代码不需要针对不同数据库分别开发；
  • Java程序编译期仅依赖java.sql包，不依赖具体数据库的jar包；
  • 可随时替换底层数据库，访问数据库的Java代码基本不变。

JDBC的使用

使用JDBC访问数据库的基本步骤

1.加载JDBC驱动程序

2.建立数据库连接

3.创建Statement对象

4.执行SQL语句

5.处理返回结果

6.释放资源

public class TestJDBC {
	public static void main(String[] args) throws Exception {
		/**
		 * 1.加载驱动类 Driver 2.获取连接 3.获取操作句柄 4.操作数据库（发送SQL语句） 5.释放资源
		 */
		/*
		 * try { Class.forName("oracle.jdbc.driver.OracleDriver"); //SPI } catch
		 * (ClassNotFoundException e) { e.printStackTrace(); }
		 */
		String url = "jdbc:oracle:thin:@localhost:1521:helowin";
		String username = "zengyusheng";
		String password = "qwe123";
		Connection conn = null;
		try {
			conn = DriverManager.getConnection(url, username, password);
		} catch (SQLException e) {
			e.printStackTrace();
		}
        
		Statement statement = conn.createStatement();
		statement.executeUpdate("update student set name='罗炫' where id=5");
		String sql = "select id,name,subject,score from student";
		ResultSet row = statement.executeQuery(sql);
		while (row.next()) {
			System.out.print(row.getInt(1) + "\t");
			System.out.print(row.getString(2) + "\t");
			System.out.print(row.getString(3) + "\t");
			System.out.print(row.getString(4) + "\n");
		}
		row.close();
		statement.close();
		conn.close();
	}
}

DriverManager

DriverManager类是JDBC的管理层,作用于应用程序和驱动程序之间,并在数据库和相应驱动程序之间建立连接.该类负责加载、注册JDBC驱动程序.使用DriverManager类的getConnection()获得一个数据库连接

Connection conn = DriverManager.getConnection(String url,String user,String password);

Connection

数据库连接接口

Statement

用于执行SQL语句,并获取查询结果,Statement接口提供了三种执行SQL语句的方

  • executeQuery():用于产生单个结果集的语句,例如select语句.
  • executeUpdate():用于执行insert、update或者delete语句以及DDL语句.
  • execute():执行给定的SQL语句,可以是任何SQL语句

PreparedStatement

预编译SQL语句Statement接口,SQL语句被预编译后并存储在 PreparedStatement 子类对象中,然后可以使用此对象多次高效地执行该语句

注：用于设置 IN 参数值的设置方法（setShort、setString 等等）必须指定与输入参数的已定义 SQL 类型兼容的类型.例如，如果 IN 参数具有 SQL 类型 INTEGER，那么应该使用 setInt 方法

 public static void main(String[] args) throws Exception {
       FileInputStream fis =new FileInputStream("/home/zengyusheng/Pictures/OSI七层模型.png");
	   Connection conn =JDBCUtils.getConnection();
	   String sql ="insert into testblob(id,test) values(?,?)";
	   PreparedStatement ps =null;
	   try {
		ps =conn.prepareStatement(sql);
		ps.setInt(1, 1);
		ps.setBinaryStream(2, fis);
		ps.executeUpdate();
	} catch (SQLException e) {
		e.printStackTrace();
	}finally {
		fis.close();
		ps.close();
		conn.close();
	}
	 
}

ResultSet

ResultSet表示查询结果,通常通过执行查询数据库的语句生成

JDBC数据类型

JDBC驱动程序将Java数据类型转换为适当的JDBC类型,然后将其发送到数据库. 它为大多数数据类型提供并使用默认映射.

SQL类型 JDBC类型 Java类型
VARCHAR java.sql.Types.VARCHAR java.lang.String
CHAR java.sql.Types.CHAR java.lang.String
LONGVARCHAR java.sql.Types.LONGVARCHAR java.lang.String
BIT java.sql.Types.BIT boolean
NUMERIC java.sql.Types.NUMERIC java.math.BigDecimal
TINYINT java.sql.Types.TINYINT byte
SMALLINT java.sql.Types.SMALLINT short
INTEGER java.sql.Types.INTEGER int
BIGINT java.sql.Types.BIGINT long
REAL java.sql.Types.REAL float
FLOAT java.sql.Types.FLOAT float
DOUBLE java.sql.Types.DOUBLE double
VARBINARY java.sql.Types.VARBINARY byte[ ]
BINARY java.sql.Types.BINARY byte[ ]
DATE java.sql.Types.DATE java.sql.Date
TIME java.sql.Types.TIME java.sql.Time
TIMESTAMP java.sql.Types.TIMESTAMP java.sql.Timestamp
CLOB java.sql.Types.CLOB java.sql.Clob
BLOB java.sql.Types.BLOB java.sql.Blob
ARRAY java.sql.Types.ARRAY java.sql.Array
REF java.sql.Types.REF java.sql.Ref
STRUCT java.sql.Types.STRUCT java.sql.Struct

使用Properties 读取配置文件

jdbc.oracle.drivername=oracle.jdbc.driver.OracleDriver
jdbc.oracle.url=jdbc:oracle:thin:@localhost:1521:helowin
jdbc.oracle.username=zengyusheng
jdbc.oracle.password=qwe123
public class JDBCUtils {
    private static Properties pro = null;
    private static final String JDBC_ORACLE_DRIVERNAME = "jdbc.oracle.drivername";
    private static final String JDBC_ORACLE_USERNAME = "jdbc.oracle.username";
    private static final String JDBC_ORACLE_PASSWORD = "jdbc.oracle.password";
    private static final String JDBC_ORACLE_URL = "jdbc.oracle.url";
    static {
        pro = new Properties();
        InputStream is = JDBCUtils.class.getResourceAsStream("/db.properties");
        try {
            if (null != is) {
                pro.load(is);
            }
            Class.forName(pro.getProperty(JDBC_ORACLE_DRIVERNAME));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        new JDBCUtils();
    }
    public static Connection getConnection() {
        Connection coon = null;
        for (int i = 0; i < 3; i++) {
        	try {
                coon = DriverManager.getConnection(pro.getProperty(JDBC_ORACLE_URL),
                        pro.getProperty(JDBC_ORACLE_USERNAME),
                        pro.getProperty(JDBC_ORACLE_PASSWORD));
                return coon;
            } catch (SQLException e) {
            }
		}
       return coon;
    }

    public static void close(Connection connection,PreparedStatement ps) {
    	try {
    		if (ps!=null) {
    			ps.close();
    		}
        	if (connection!=null) {
    			connection.close();
    		}
		} catch (Exception e) {
			e.printStackTrace();
		} 
    }
}
com.qst.jdbc.mysql.driver=com.mysql.jdbc.Driver
com.qst.jdbc.mysql.user=root
com.qst.jdbc.mysql.password=123456
com.qst.jdbc.mysql.url=jdbc:mysql://localhost:3306/demo_db?useUnicode=true&characterEncoding=utf8
Connection conn = null;
		try {
			ResourceBundle rb = ResourceBundle.getBundle("com.qst.javaee.config.db");
			String driver = rb.getString("com.qst.jdbc.mysql.driver");
			String user = rb.getString("com.qst.jdbc.mysql.user");
			String password = rb.getString("com.qst.jdbc.mysql.password");
			String url = rb.getString("com.qst.jdbc.mysql.url");
			Class.forName(driver);
			conn = DriverManager.getConnection(url, user, password);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}

JDBC连接池

JDBC连接池有一个标准的接口javax.sql.DataSource，注意这个类位于Java标准库中，但仅仅是接口。要使用JDBC连接池，我们必须选择一个JDBC连接池的实现。常用的JDBC连接池有：

  • HikariCP
  • C3P0
  • BoneCP
  • Druid

目前使用最广泛的是HikariCP

public class TestDataSource {
	public static void main(String[] args) throws Exception {
		HikariDataSource dataSource=new HikariDataSource();		                                                                         dataSource.setJdbcUrl("jdbc:oracle:thin:@localhost:1521:helowin");	                                                             dataSource.setDriverClassName("oracle.jdbc.driver.OracleDriver");
		dataSource.setUsername("zengyusheng");
		dataSource.setPassword("qwe123");
		long start=System.currentTimeMillis();
		for (int i = 0; i < 100000; i++) {
			Connection conn =dataSource.getConnection();
//			Connection conn=JDBCUtils.getConnection();
			conn.close();
		}
		long end=System.currentTimeMillis();
		System.out.println(end-start);
	}
}

分页查询

public class PageSplit<T> {
	private int currentPage;
	private int pageSize;
	private int totalCount;
	private int pageCount;
	private List<T> list=new ArrayList<>();
	
	public int getCurrentPage() {
		return currentPage;
	}
	public void setCurrentPage(int currentPage) {
		this.currentPage = currentPage;
	}
	public int getPageSize() {
		return pageSize;
	}
	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}
	public int getTotalCount() {
		return totalCount;
	}
	public void setTotalCount(int totalCount) {
		this.totalCount = totalCount;
	}
	public int getPageCount() {
		return pageCount;
	}
	public void setPageCount(int pageCount) {
		this.pageCount = pageCount;
	}
	public List<T> getList() {
		return list;
	}
	public void setList(List<T> list) {
		this.list = list;
	}
}
public static PageSplit<Student> get(int currentPage, int pageSize) {
		PageSplit<Student> pages = new PageSplit<Student>();
		Connection conn = JDBCUtils.getConnection();
		if (null == conn) {
			return pages;
		}
		int totalCount=0;
		try {
			ResultSet resultSet=conn.createStatement().executeQuery("select count(1) from student2");
			if (resultSet.next()) {
				 totalCount=resultSet.getInt(1);
			}
		} catch (SQLException e1) {
			e1.printStackTrace();
		}
		pages.setTotalCount(totalCount);
		int pageCount=(totalCount+pageSize-1)/pageSize;
		pages.setPageCount(pageCount);
	
		if (currentPage<=0) {
			currentPage=1;
		}
		if (currentPage>=pageCount) {
			currentPage=pageCount;
		}
		pages.setCurrentPage(currentPage);
		pages.setPageSize(pageSize);
		
		ResultSet resultSet =null;
		PreparedStatement ps =null;
        String pageSplitSql="select id,name,age,gender from (select rownum r,id,name,age,gender from student2 where rownum<=?"
        		+ ") t where t.r>?";
		try {
          ps =conn.prepareStatement(pageSplitSql);
          ps.setInt(1, currentPage*pageSize);
          ps.setInt(2, (currentPage-1)*pageSize);
          resultSet=ps.executeQuery();
          System.out.println(pageSplitSql);
          List<Student> students=new ArrayList<Student>();
          while(resultSet.next()) {
        	  Student student=new Student();
        	  student.setId(resultSet.getInt(1));
        	  student.setName(resultSet.getString(2));
        	  student.setAge(resultSet.getInt(3));
        	  student.setGender(resultSet.getBoolean(4));
        	  students.add(student);
          }
          pages.setList(students);
          return pages;
		} catch (SQLException e) {
			e.printStackTrace();
		}finally {
			JDBCUtils.close(conn, ps);
		}
		return null;
	}

你可能感兴趣的:(java,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()，那么我们在接口
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 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的运行
  • Low Power概念介绍-Voltage Area 飞奔的大虎
    随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
  • 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
  • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • uniapp map组件自定义markers标记点 以对_ uni-app学习记录uni-appjavascript前端
    需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • 笋丁网页自动回复机器人V3.0.0免授权版源码 希希分享 软希网58soho_cn源码资源笋丁网页自动回复机器人
    笋丁网页机器人一款可设置自动回复，默认消息，调用自定义api接口的网页机器人。此程序后端语言使用Golang，内存占用最高不超过30MB，1H1G服务器流畅运行。仅支持Linux服务器部署，不支持虚拟主机，请悉知！使用自定义api功能需要有一定的建站基础。源码下载：https://download.csdn.net/download/m0_66047725/89754250更多资源下载：关注我。安
  • 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
  • 分享100个最新免费的高匿HTTP代理IP mcj8089 代理IP代理服务器匿名代理免费代理IP最新代理IP
      推荐两个代理IP网站：   1. 全网代理IP：http://proxy.goubanjia.com/   2. 敲代码免费IP：http://ip.qiaodm.com/     120.198.243.130:80,中国/广东省 58.251.78.71:8088,中国/广东省 183.207.228.22:83,中国/
  • mysql高级特性之数据分区 annan211 java数据结构mongodb分区mysql
    mysql高级特性 1 以存储引擎的角度分析，分区表和物理表没有区别。是按照一定的规则将数据分别存储的逻辑设计。器底层是由多个物理字表组成。 2 分区的原理 分区表由多个相关的底层表实现，这些底层表也是由句柄对象表示，所以我们可以直接访问各个分区。存储引擎管理分区的各个底层 表和管理普通表一样(所有底层表都必须使用相同的存储引擎)，分区表的索引只是
  • JS采用正则表达式简单获取URL地址栏参数 chiangfai js地址栏参数获取
    GetUrlParam:function GetUrlParam(param){ var reg = new RegExp("(^|&)"+ param +"=([^&]*)(&|$)"); var r = window.location.search.substr(1).match(reg); if(r!=null
  • 怎样将数据表拷贝到powerdesigner (本地数据库表) Array_06 powerDesigner
    ================================================== 1、打开PowerDesigner12，在菜单中按照如下方式进行操作 file->Reverse Engineer->DataBase 点击后，弹出 New Physical Data Model 的对话框 2、在General选项卡中 Model name:模板名字，自
  • logbackのhelloworld 飞翔的马甲 日志logback
    一、概述 1.日志是啥？ 当我是个逗比的时候我是这么理解的：log.debug()代替了system.out.print(); 当我项目工作时，以为是一堆得.log文件。 这两天项目发布新版本，比较轻松，决定好好地研究下日志以及logback。 传送门1：日志的作用与方法： http://www.infoq.com/cn/articles/why-and-how-log 上面的作
  • 新浪微博爬虫模拟登陆 随意而生 新浪微博
    转载自：http://hi.baidu.com/erliang20088/item/251db4b040b8ce58ba0e1235     近来由于毕设需要，重新修改了新浪微博爬虫废了不少劲，希望下边的总结能够帮助后来的同学们。      现行版的模拟登陆与以前相比，最大的改动在于cookie获取时候的模拟url的请求
  • synchronized 香水浓 javathread
        Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然
  • maven 简单实用教程 AdyZhang maven
    1. Maven介绍  1.1. 简介 java编写的用于构建系统的自动化工具。目前版本是2.0.9，注意maven2和maven1有很大区别，阅读第三方文档时需要区分版本。 1.2. Maven资源 见官方网站；The 5 minute test，官方简易入门文档；Getting Started Tutorial，官方入门文档；Build Coo
  • Android 通过 intent传值获得null aijuans android
    我在通过intent 获得传递兑现过的时候报错，空指针,我是getMap方法进行传值，代码如下 1 2 3 4 5 6 7 8 9 public void getMap(View view){            Intent i =
  • apache 做代理 报如下错误：The proxy server received an invalid response from an upstream baalwolf response
    网站配置是apache＋tomcat,tomcat没有报错，apache报错是： The proxy server received an invalid response from an upstream server. The proxy server could not handle the request GET /. Reason: Error reading fr
  • Tomcat6 内存和线程配置 BigBird2012 tomcat6
    1、修改启动时内存参数、并指定JVM时区 （在windows server 2008 下时间少了8个小时） 在Tomcat上运行j2ee项目代码时，经常会出现内存溢出的情况，解决办法是在系统参数中增加系统参数：  window下， 在catalina.bat最前面 set JAVA_OPTS=-XX:PermSize=64M -XX:MaxPermSize=128m -Xms5
  • Karam与TDD bijian1013 KaramTDD
    一.TDD         测试驱动开发（Test-Driven Development,TDD）是一种敏捷（AGILE）开发方法论，它把开发流程倒转了过来，在进行代码实现之前，首先保证编写测试用例，从而用测试来驱动开发（而不是把测试作为一项验证工具来使用）。         TDD的原则很简单： a.只有当某个
  • [Zookeeper学习笔记之七]Zookeeper源代码分析之Zookeeper.States bit1129 zookeeper
    public enum States { CONNECTING, //Zookeeper服务器不可用，客户端处于尝试链接状态 ASSOCIATING, //？？？ CONNECTED, //链接建立，可以与Zookeeper服务器正常通信 CONNECTEDREADONLY, //处于只读状态的链接状态，只读模式可以在
  • 【Scala十四】Scala核心八：闭包 bit1129 scala
    Free variable A free variable of an expression is a variable that’s used inside the expression but not defined inside the expression. For instance, in the function literal expression (x: Int) => (x
  • android发送json并解析返回json ronin47 android
    package com.http.test; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpGet; import
  • 一份IT实习生的总结 brotherlamp PHPphp资料php教程php培训php视频
    今天突然发现在不知不觉中自己已经实习了 3 个月了，现在可能不算是真正意义上的实习吧，因为现在自己才大三，在这边撸代码的同时还要考虑到学校的功课跟期末考试。让我震惊的是，我完全想不到在这 3 个月里我到底学到了什么，这是一件多么悲催的事情啊。同时我对我应该 get 到什么新技能也很迷茫。所以今晚还是总结下把，让自己在接下来的实习生活有更加明确的方向。最后感谢工作室给我们几个人这个机会让我们提前出来
  • 据说是2012年10月人人网校招的一道笔试题-给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 将重物放到天平左侧，问在两边如何添加砝码 bylijinnan java
    public class ScalesBalance { /** * 题目： * 给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 （假设N无限大，但一种重量的砝码只有一个） * 将重物放到天平左侧，问在两边如何添加砝码使两边平衡 * * 分析： * 三进制 * 我们约定括号表示里面的数是三进制，例如 47=(1202
  • dom4j最常用最简单的方法 chiangfai dom4j
    要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在 http://www.dom4j.org/目前最新dom4j包下载地址:http://nchc.dl.sourceforge.net/sourceforge/dom4j/dom4j-1.6.1.zip 解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要
  • 简单HBase笔记 chenchao051 hbase
     一、Client-side write buffer 客户端缓存请求 描述：可以缓存客户端的请求，以此来减少RPC的次数，但是缓存只是被存在一个ArrayList中，所以多线程访问时不安全的。 可以使用getWriteBuffer()方法来取得客户端缓存中的数据。 默认关闭。 二、Scan的Caching 描述： next( )方法请求一行就要使用一次RPC,即使
  • mysqldump导出时出现when doing LOCK TABLES daizj mysqlmysqdump导数据
    　　执行　mysqldump -uxxx -pxxx -hxxx -Pxxxx database tablename > tablename.sql　 导出表时，会报 mysqldump: Got error: 1044: Access denied for user 'xxx'@'xxx' to database 'xxx' when doing LOCK TABLES 解决
  • CSS渲染原理 dcj3sjt126com Web
      从事Web前端开发的人都与CSS打交道很多，有的人也许不知道css是怎么去工作的，写出来的css浏览器是怎么样去解析的呢？当这个成为我们提高css水平的一个瓶颈时，是否应该多了解一下呢？          一、浏览器的发展与CSS           
  • 《阿甘正传》台词 dcj3sjt126com
    Part Ⅰ: 《阿甘正传》Forrest Gump经典中英文对白 Forrest: Hello! My names Forrest. Forrest Gump. You wanna Chocolate? I could eat about a million and a half othese. My momma always said life was like a box ochocol
  • Java处理JSON dyy_gusi json
    Json在数据传输中很好用，原因是JSON 比 XML 更小、更快，更易解析。 在Java程序中，如何使用处理JSON，现在有很多工具可以处理，比较流行常用的是google的gson和alibaba的fastjson，具体使用如下： 1、读取json然后处理 class ReadJSON { public static void main(String[] args)
  • win7下nginx和php的配置 geeksun nginx
    1.  安装包准备 nginx :  从nginx.org下载nginx-1.8.0.zip php： 从php.net下载php-5.6.10-Win32-VC11-x64.zip， php是免安装文件。 RunHiddenConsole: 用于隐藏命令行窗口   2. 配置 # java用8080端口做应用服务器，nginx反向代理到这个端口即可 p
  • 基于2.8版本redis配置文件中文解释 hongtoushizi redis
    转载自： http://wangwei007.blog.51cto.com/68019/1548167        在Redis中直接启动redis-server服务时, 采用的是默认的配置文件。采用redis-server   xxx.conf 这样的方式可以按照指定的配置文件来运行Redis服务。下面是Redis2.8.9的配置文
  • 第五章 常用Lua开发库3-模板渲染 jinnianshilongnian nginxlua
    动态web网页开发是Web开发中一个常见的场景，比如像京东商品详情页，其页面逻辑是非常复杂的，需要使用模板技术来实现。而Lua中也有许多模板引擎，如目前我在使用的lua-resty-template，可以渲染很复杂的页面，借助LuaJIT其性能也是可以接受的。   如果学习过JavaEE中的servlet和JSP的话，应该知道JSP模板最终会被翻译成Servlet来执行；而lua-r
  • JZSearch大数据搜索引擎 颠覆者 JavaScript
    系统简介： 大数据的特点有四个层面：第一，数据体量巨大。从TB级别，跃升到PB级别；第二，数据类型繁多。网络日志、视频、图片、地理位置信息等等。第三，价值密度低。以视频为例，连续不间断监控过程中，可能有用的数据仅仅有一两秒。第四，处理速度快。最后这一点也是和传统的数据挖掘技术有着本质的不同。业界将其归纳为4个“V”——Volume，Variety，Value，Velocity。大数据搜索引
  • 10招让你成为杰出的Java程序员 pda158 java编程框架
    如果你是一个热衷于技术的  Java 程序员， 那么下面的 10 个要点可以让你在众多 Java 开发人员中脱颖而出。 　　 1. 拥有扎实的基础和深刻理解 OO 原则 　　对于 Java 程序员，深刻理解 Object Oriented Programming（面向对象编程）这一概念是必须的。没有 OOPS 的坚实基础，就领会不了像 Java 这些面向对象编程语言
  • tomcat之oracle连接池配置 小网客 oracle
    tomcat版本7.0 配置oracle连接池方式： 修改tomcat的server.xml配置文件： <GlobalNamingResources> <Resource name="utermdatasource" auth="Container" type="javax.sql.DataSou
  • Oracle 分页算法汇总 vipbooks oraclesql算法.net
        这是我找到的一些关于Oracle分页的算法，大家那里还有没有其他好的算法没？我们大家一起分享一下！ -- Oracle 分页算法一 select * from ( select page.*,rownum rn from (select * from help) page -- 20 = (currentPag
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他