Java100:javaSE备忘

2024-09-03 22:32
文章标签 java se 100 备忘

本文主要是介绍Java100:javaSE备忘,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!


char c='\u4e00' //汉字开始

char c='\u9fa5'//汉字结束


java 正则   正则表达式:  java.util.regex.Pattern

    [] 匹配的一个字符

    [^a] 一个非a的字符

    [^abcd]一个非a,b,c,d的字符

    [A-Z] 一个 A-Z 的字符

    [a-z] 一个a-z的字符

    [0-9] 一个0-9 的字符

    [a-z&&[^bc]]一个a-z的字符 而且不能是bc

     . 任意一个字符

    \d 任意一个数字 

    \w[a-zA-Z0-9_]

    \s空白字符 [\y\n\xOB\f\r]

    \D非 \d

    \W非 \w

    \S非 \s

    量词

    [0-9]? 0 或者1

    [0-9]* 0 到无限

    [0-9]+ 最少一个

    [0-9]{6} 必须6个

    [0-9]{6,}最少6个

    [0-9]{0,6}最多6个

    [0-9]{6,9}6-18位

    (\+86) +86 这个整体

    位置限定符

    ^ 第一个字符

    $ 最后一个字符

    分组

    ()

    特殊字符转义

    \

    ^[\w]+@[\w]+(\.[a-zA-Z0-9]+)+$


    但是 java中的String 中的matches 中的匹配时全匹配 也就是^ $ 你加不加 java 都帮你加上了


    | 或的意思

    (0086|\+86) 0086 或者 +86




    Object  是所有类的父类

    Object  东西

        toString()方法

            1)返回对象文本描述

            2)被很多API默认调用

              3)建议重写toString方法,对象的文本描述

             4)建议自定义的每一类增加toString()方法

        

        equals 方法: 比较两个对象的内容是否一样

            instanceof

            instance of 的实例

        == 比较变量的值,引用变量的值是地址值 比的是对象的地址(引用类型变量 指向的地址)

            也就是比较的是否是同一个对象

package se.day001;
/*** 斗地主* @author 煊**/
public class Card {/** 花色*/private int suit;/** 点数*/private int rank;public static final int THREE=0;public static final int FOUR=1;public static final int FIVE=2;public static final int SIX=3;public static final int SEVEN=4;public static final int EIGHT=5;public static final int NINE=6;public static final int TEN=7;public static final int JACK=8;public static final int QUEEN=9;public static final int KING=10;/*** A*/public static final int ACE=11;/*** 2*/public static final int DEUCE=12;/*** 小王*/public static final int BLACK=13;/*** 大王*/public static final int COLOR=14;/*** 方块*/public static final int DIAMOND = 0;/*** 梅花*/public static final int CLUB = 1;/*** 红桃*/public static final int HRART = 2;/*** 黑桃*/public static final int SPADE = 3;/*** 王*/public static final int JOKER = 4;public Card(int suit,int rank){this.suit = suit;this.rank = rank;}public int getSuit(){return suit;}public int getRank(){return rank;}public void setSuit(int suit){this.suit = suit;}public void setRank(int rank){this.rank = rank;}private  static String[] suitName = {"方块","梅花","红桃","黑桃",""};private  static String[] rankName = {"3","4","5","6","7","8","9","10","J","Q","K","A","2","小王","大王"};@Overridepublic String toString(){return "点数:"+rankName[rank]+";花色:"+suitName[suit];}@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + rank;result = prime * result + suit;return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if(obj instanceof Card){Card other = (Card)obj;return this.rank ==other.rank && this.suit == other.suit;}return false;}}
package se.day001;
/*** 建议重写toString方法,对象的文本描述* @author 煊**/
public class Dmeo01 {public static void main(String[] args){Card ace = new Card(Card.SPADE,Card.ACE);String whatIsIt = ace.toString();System.out.println(whatIsIt);Card c1 = new Card(Card.DEUCE,Card.TEN);Card c2 = new Card(Card.DEUCE,Card.TEN);Card c3 = c1;System.out.println(c1==c2);System.out.println(c1==c3);System.out.println(c1.equals(c2));System.out.println(c1.equals(c3));}}
package se.day001;public class Demo02 {public static void main(String[] args){Object o1 = new Card(Card.DIAMOND,Card.THREE);Object o2 = "方块3";System.out.println(IsCard(o1));System.out.println(IsCard(o2));}public static boolean IsCard(Object o){if(o ==null){return false;}else{return (o instanceof Card);}}}


String 类的特点

    字符串是字符数组组成的 

    字符串 对象 是不可改变的,字符串引用可以重新赋值

    为了提高性能,静态字符串(字面量/常量/常量连接的结果)在静态池中创建,尽量使用同一个对象,重用静态字符串

package se.day001;import java.util.Arrays;/*** 实现 字符数组内容转为小写* 实现 字符数组内容转为大写* @author 煊**/
public class Demo03 {public static void main(String[] args){char[] chs = {'I','l','o','v','e','u'};char[] chs2 = Arrays.copyOf(chs, chs.length);for(int i = 0;i<chs.length;i++){if(chs2[i]>'A' && chs2[i]<'Z'){chs2[i]=(char)(chs2[i]-('A'-'a'));} }System.out.println(chs);System.out.println(chs2);String str = "I love u";System.out.println(str);System.out.println(str.toLowerCase());System.out.println(str.toUpperCase());}
}




package se.day02;
/*** 正则* @author zongx**/
public class StringDemo {public static void main(String[] args){if(Test.email("81240805@qq.com")){System.out.println("yes");}else{System.out.println("no");}if(Test.ID("321321199909191099")){System.out.println("yes");}else{System.out.println("no");}}
}class Test{public static boolean email(String email){String regex = "[\\w]+@[\\da-zA-Z0]+(\\.[\\da-zA-Z]+)+";//String mail = "81240805@qq.com";return email.matches(regex);//全匹配}public static boolean ID(String ID){String regex ="[1-9]\\d{14}(\\d{2}[\\dxX])?";return ID.matches(regex);}
}

 

package se.day02;
/*** 将字符串 中满足正则表达式的部分替换为给定内容* @author 煊**/
public class StringDemo3 {public static void main(String[] args){String str ="asdfhaj lh8349 38 512 jlkg0erg 03u0 24 ";str = str.replaceAll("\\d+", "AA");System.out.println(str);String regex ="(sb|wqnmlgb|cnm|djb)";String msg = "sb,你个djb";String message = msg.replaceAll(regex, "****");System.out.println(message);}
}

 

Java 的字符串连接的过程是利用StringBuilder 实现的

建议在大量字符串计算的时候利用StringBuilder


String

StringBuilder

    api方法是对其那内部char[] 内容进行 增删改查方法

    

package se.day001;public class Demo05 {public static void main(String[] args){StringBuilder buf = new StringBuilder();System.out.println(buf.append("123"));//增System.out.println(buf.delete(0, 1));//删System.out.println(buf.insert(0,"4"));//插入System.out.println(buf.indexOf("4"));//查System.out.println(buf.append("123"));System.out.println(buf.replace(1,2, "22"));//替换System.out.println(buf.reverse());//反转}
}

StringBuffer

package se.day001;public class Demo06 {public static void main(String[] args){StringBuffer buf = new StringBuffer();System.out.println(buf.append("123"));//增System.out.println(buf.delete(0, 1));//删System.out.println(buf.insert(0,"4"));//插入System.out.println(buf.indexOf("4"));//查System.out.println(buf.append("123"));System.out.println(buf.replace(1,2, "22"));//替换System.out.println(buf.reverse());//反转}
}


StringBuffer 和 StringBuilder 

比较:StringBuffer 早于StringBuilder(快)

线程安全 StringBuffer 同步处理,性能稍慢

    多线程使用

非线程安全 StringBuilder 并发处理,性能稍快

    单线程使用

Java 中代表字符串的有 char[] String StringBuilder

    char[] 只是字符数据,没有算法  用它就要自己实现方法 可能性能高 开发效率低

    String 是不可变字符串 是最常用的字符串 java数据大多就是使用String 输出的

    StringBuilder 是可变字符串,字符串的内容计算,建议采用StringBuilder实现,性能好

    

    8个基本类型不是Object 的子类 也就是说 他们不是东西。

    包装类 就是可以使8个基本类型可以参与到面向对象

    都是final的

    

    Byte          byte

    Short        short

    Integer       int

    Long          long

    Float         float

    Double         double

    还继承了java.lang.Object

-------------------------------------------

             Character                   char

    Boolean        boolean

    继承了java.lang.Object

---------------------------------------

    创建的时候建议使用 常量池的方式 节省内存

    Integer i = Intger.valueOf(1);

    Integer i2 = new Integer(1);


    

java1.5 之后的变革

自动拆装箱:拆箱    自动将包装类对象转换为基本类型

 :装箱    自动将基本类型数据转换为包装类对象

    使用更加方便














System.out.println("-----------------");
int i3 = i;
System.out.println(i3);
Integer i4 = 1;
System.out.println(i4);
//提供两个常量 最大 和最小值
System.out.println(Integer.MAX_VALUE);
System.out.println(Integer.MIN_VALUE);
//将字符串转换为基本类型
String str = "1231234";
int i5 = Integer.parseInt(str);
System.out.println(i5);
String str2 = "123.123";
double d3 = Double.parseDouble(str2);
System.out.println(d3);//将整数转换为2进制形式的字符串
int num = 100;
String bStr = Integer.toBinaryString(num);
System.out.println(bStr);
//转换16进制
String hStr = Integer.toHexString(num);
System.out.println(hStr);
double d4 = 100.101;
String dStr = Double.toString(d4);
System.out.println(d4);

BigDecimal类

BigDecimal  大小数

对小数做精确计算时,double不能描述的时候,就要使用这个类BigDecimal对小数做精确计算



BigInteger类


BigInteger 大整数

保存更长的整数,取值范围受内存限制,在long 不能满足的时候使用BigInteger







Java 中的时间


    是一个long类型的整数,是GMT 1970年元旦到显示累计的毫秒数

    时间的计算就是 毫秒数的 + -


UTC 时间:1970/01/01/00:00:00;


java.util.Date类

getYear(); 有2000年问题 需要+1900

getMonth();返回月份 从0开始 也就是要 +1

getDay();返回星期几

getTime();返回long毫秒值

setTime(long);修改时间毫秒值


SimpleDateFormat


    format方法:将Date 对象转换为特定格式的字符串

    parse方法:将字符串按照特定格式转换为Date对象  

package se.day001;
//      yyyy     2016
//      yy       16
//      MM       01
//      M         1
//      dd       13
//      d         6
//      E       星期三
//      a       a- 下午
//      H       24小时制
//      h       12小时制
//      m       份
//      s       秒
import java.text.SimpleDateFormat;
import java.util.Date;public class Demo07 {public static void main(String[] args){Date t = new Date();System.out.println(t.getYear());System.out.println(t.getYear()+1900);System.out.println(t.getMonth()+1);System.out.println(t.getDate());System.out.println(t.getDay());t.setTime(0);System.out.println(t.getYear());SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String str = fmt.format(t);System.out.println(str);System.out.println(fmt.format(0));//可以使用long值}
}


DateFormat类

    是SimpleDateFormat的父类创建实例时只需要条用其提供的一个静态方法getInstance()

package se.day001;import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;public class Demo09 {public static void main(String[] args){Date date = new Date();/*** style 对应的常量 LONG SHORT MEDIUM* 通常使用MEDIUM* Locale 类*  对应的地区*/DateFormat df = DateFormat.getDateInstance(DateFormat.LONG,Locale.CHINA);System.out.println(df.format(date));}
}


Calendar 类     

    可以方便的尽心日期的计算

    获取日期中的信息考虑了时区等问题

    抽象类   操作时间 判断时间

    创建实例通常可以使用提供的工厂方法

    getInstance()

    该方法自动根据当前系统所处地区创建对应时区的实现类

package se.day001;import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;public class Demo10 {public static void main(String[] args){Calendar calendar = Calendar.getInstance();SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");System.out.println(calendar);Date date = calendar.getTime();System.out.println(sdf.format(date));//设置一个时间点calendar.set(Calendar.YEAR, 1111);calendar.set(Calendar.MONTH,Calendar.NOVEMBER);calendar.set(Calendar.DAY_OF_MONTH,11);System.out.println(calendar.getTime());calendar.set(Calendar.DAY_OF_MONTH,1111);System.out.println(calendar.getTime());calendar.set(Calendar.HOUR_OF_DAY, 11);calendar.set(Calendar.MINUTE, 11);calendar.set(Calendar.SECOND, 11);System.out.println(calendar.getTime());int week = calendar.get(Calendar.DAY_OF_WEEK);System.out.println(week);//国外星期天是第一天int day = calendar.get(Calendar.DAY_OF_YEAR);System.out.println(day);int sumOfYear = calendar.getActualMaximum(Calendar.DAY_OF_YEAR);//传入的年的最大值int sumOfMonth = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);//传入的月的最大值System.out.println(sumOfYear);System.out.println(sumOfMonth);}
}


java 中的集合框架

Collection接口

 接口定义集合的相关特征

集合:

            Collection

            两个子接口

    

    List集合                Set集合

    可重复     equals       不可重复

    有序的               无序的

    ArrayList            HashSet

    内部使用数组            散列算法

    LinkedList            TreeeSet

    内部使用链表            二叉树


ArrayList 使用数组方法实现,这种集合更适合查询数据,但是对频繁的增删元素 效率低

LinkedList 使用链表方法实现,这种集合更适合增删元素,但是对频繁的查询元素 效率低


基本类型有自动装箱


迭代器:

    用于遍历集合元素

调用集合定义的方法iterator()


Iterator 接口

    定义了遍历集合时的相关方法

不同的集合有着不同的迭代器实现

该接口有三个常用的方法:

    boolean hasNext(): 是否还有元素可以获取

    Object next():获取元素

    void remove():删除当前迭代出的元素

 遍历集合的顺序: 问取删(删可以不做)

         删除只能通过迭代器remove 删除

 泛型    1.5以后有的 

    泛型的本质就是参数化类型,再使用某个类时为方法属性等指定类型


新循环 1.5之后

 新循环是使用迭代器的形式实现的 so 不能通过集合删除元素

    int[] arr = {1,2,3,4,5};

    for(int i:arr){

        System.out.println(i);

    }


数据结构:

    队列 Queue

        先进先出(FIFO)First Input First Output

        Queue 重用的子类实现LinkedList

        LinkedList 实现了集合 也实现了队列

        也支持泛型


    Deque 双端队列==》栈

      是Queue的子接口

      双进双出


        使用双端队列时,若只允许元素都一个方向进出,就实现了栈

        栈有良好的实力追溯性

            先进后出FILO(First Input Last Output)

                就像子弹夹

            浏览器上的前进和后退



Comparable 接口 

  在对数组或集合元素进行排序时,首先要确定比较大小,有了结论才可以进行排序,而如何比较大小则需要实现该接口 并实现compareto方法

    需要实现 compareTo方法

返回值不在乎集体的值 只关心取值的范围

>0 当前对象比给定的对象大

<0 当前对象比给定对象小

=0 当前对象和给定对象相等

compareTo方法的返回值应该与equals 方法的返回值具有一致性

    当两个对象的equals 方法返回true时 compareTo方法应该返回0



Collections 集合的工具类

    sort方法 用于排序集合  会调用compareTo方法

java 中的很多类都实现了Comparable 接口 

想要自定义比较规则:

    sort(Collections c,Comparator com)

                比较器

                    用来定义比较规则

    不适用集合中元素自身的比较规则,而是使用自己提供的比较器中的比较规则静静比较后再进行排序





Map 接口

    Map 接口定义idea集合包含两个部分

    key-value 以键值对的形式保存元素,可以把map看作是一个多行两列的表格

    HashMap      TreeMap

    在Map中,key 是不重复的





异常 

    ERROR

        jvm 级别的错误

         栈内存溢出

    Exception

        程序级别的错误

         通过捕获机制来解决


catch语句是用来捕获try语句中出现 并针对该异常解决,catch语句块可以出现多次

捕获异常:应该在最后一个catch 中加入Exception  可以保证程序不会因为没有捕获到一个未知的异常而中断, 而且这个Exception 应该放在所有catch 的最后一个..

    try{


   }catch(){

    

    }finally{

     

     }



finally出现在try语句的最后

finally块中的语句是必然执行的无论try中是否出现异常

 用于收尾工作


    throws 抛出异常


thorws 声明

    在当前方法中出现异常,但是处理这个异常的责任不是当前方法管,这时候就把异常抛出去

    谁调用 谁来解决

    当程序遇到满足语法要求,但是不符合业务逻辑的 也可以使用thorws 一个异常

    通常情况下方法中 throw一个异常实例我必须处理这个异常 处理的方式有两种

    1,为throw 添加try{}catch(){}

    2,在当前方法是声明该类异常的抛出,通知调用者处理该异常

我们定义的方法中可能会出现错误,无论是否为我们主动抛出的,但只要是方法中出现的异常不在方法中处理的,我们通常在声明方法是同事申明可能会抛出的异常,通知调用者必须捕获




java 文件操作

    File类

    用于描述操作系统中的一个文件或者目录通过File 可以得知文件的名字,大小,修改时间等信息但是不能读物文件的内容

    描述文件路径时,尽量使用相对路径,便于跨平台的使用

    .  表示当前目录,这个目录就时当前项目的根目录

    File file = new File("."+File.separator+"1.txt");

    

    创建目录需要两部

        使用File 对象描述要创建的目录

        通过File 对象的方法创建目录

    File file = new File("."+File.separator+"asdf");

    file.mkdir();



    File sub = new File(dir,"sub");

    sub.mkdir();


    

     File file2 = new File("."+File.separator+"asdf"+File.separator+"asdf"+File.separator+"asdf"+File.separator+"asdf"+File.separator+"asdf"+File.separator+"asdf");

    file.mkdirs();


    File file3 = new File("."+File.separator+"lmdtx.txt");

    try{

        file3.createNewFile();

    }catech(Exception e){

        

    }   

package se.day001;import java.io.File;
import java.io.IOException;
import java.util.Scanner;public class Demo18 {public static void main(String[] args){File file = new File("."+File.separator+"zxzx");Scanner con = new Scanner(System.in);if(file.exists()){System.out.println("file is exists,will delete this file(Y/N):");if("Y".equals(con.nextLine())){file.delete();System.out.println("fils delete");file.mkdir();System.out.println("file mk");}else{System.out.println("no del");}}else{file.mkdir();}File file2 = new File("."+File.separator+"file.txt");try {file2.createNewFile();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}
}

    

package se.day001;import java.io.File;
import java.io.IOException;public class Demo17 {public static void main(String[] args){File file = new File("."+File.separator+"zxzcv.txt");if(file.exists()){System.out.println("have");}else{System.out.println("cretae file ");try {file.createNewFile();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}
}
package se.day001;import java.io.File;
import java.io.IOException;public class Demo16 {public static void main(String[] args){File dir = new File("."+File.separator+"asdf");if(dir.exists()){System.out.println("have this dir,can not make");try {System.out.println(dir.getCanonicalPath());} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}else{dir.mkdir();}File sub = new File(dir,"sub");if(sub.exists()){System.out.println("have");}else{sub.mkdir();}}
}
package se.day001;import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;public class Demo15 {public static void main(String[] args){File file = new File("."+File.separator+"ttt.txt");if(file.exists()){System.out.println("yes");}else{System.out.println("no");}if(file.isFile()){System.out.println("File");}else{System.out.println("noFile");}if(file.isDirectory()){System.out.println("dir");}else{System.out.println("noDir");}System.out.println(file.getName());System.out.println(file.length());System.out.println(file.getPath());System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(file.lastModified())));System.out.println(file.getAbsolutePath());try{			System.out.println(file.getCanonicalPath());}catch(Exception e){System.out.println("no this ");}if(file.canRead()){System.out.println("can read");}else{System.out.println("can not read");}if(file.canWrite()){System.out.println("can write");}else{System.out.println("can not write");}if(file.canExecute()){System.out.println("can exe");}else{System.out.println("can not exe");}}
}
package se.day001;import java.io.File;public class Demo19 {public static void main(String[] args){File src = new File(".");String[] subFileName = src.list();for(String sub:subFileName){System.out.println(sub);}File[] subs = src.listFiles();for(File sub:subs){System.out.println(sub.getName()+":"+sub.length());}}
}

  若给定的File对象是一个目录要先将子项全部删除后才能删除它

    递归调用,删除给定的子项File

package se.day001;import java.io.File;public class Demo20 {public static void main(String[] args){File dir = new File("."+File.separator+"aa");if(dir.exists()){delFile(dir);System.out.println("del all ");}else{System.out.println("no this dir");}}public static void delFile(File file){if(file.isDirectory()){File[] subFiles = file.listFiles();for(File subFile:subFiles){delFile(subFile);}}file.delete();}
}


文件过滤器

接口



RandomAccessFile 

 用于读写文件内容的类



java 中文件模型

    数据在硬盘中保存的形式是byte by byte

读写文件实际上就是读写字节

    创建RandomAccessFile 

RandomAccessFile(File file,String mode)

mode :

    rw  读写

    r  只读

一次写一个字节

8位

File file = new File('.'+File.separator+"xxxxxxxx.log")

RandomAccessFile raf = new RandomAccessFile(file,"rw");

raf.write('a');

int max = Integer.MAX_VALUE;

raf.write(max>>>24);

raf.write(max>>>16);    ==>   raf.writeInt(Integer.MAX_VALUE);

raf.write(max>>>8);     ==>

raf.write(max);

8个基本类型都有



写字符串

给write 一个byte 数组也是可以得

按照utf-8;

String str = "my name is lmdtx";

byte[] data = str.getBytes("utf-8");

raf.write(data);

raf.close();



通常在写字符串的时候,不是直接把字符串转换的字节先写出去,而是要先写一个整数,这个整数表示后面将要写的字符串的总字节量,这样便于读取,否则在读取的时候无法确定读取多少个字节才能完整的读取所有字符串


读取

读取一个字节 以 int 形式返回

当返回值为-1的时候 读取到文件的末尾

该int值 只有低8位有效


File file = new File('.'+File.separator+"xxxxxxxx.log");

RandomAccessFile raf = new RandomAccessFile(file,"r");

char a = (char)raf.read();

int num = 0;

int i = raf.read();

num = (i<<24)|num;

i = raf.read();

num = (i<<16)|num;

i = raf.read();

num = (i<<8)|num;

i = raf.read();

num = i|num;

System.out.println(num == Imteger.MAX_VALUE);

int max = raf.readInt();

System.out.println(num == max);

raf.close();



读取字符串

    int read(byte[] data)

一次性读取data数组长度的字节量,并存入该数组中,

返回值为实际读取到的字节量

若返回值为-1 读取到了文件末尾

byte[] data = new byte[raf.readint()];

raf.read(data);

String str = new String(data,"utf-8");

System.out.println(str);

raf.close();


读取写入utf-8

File file =new File("123.txt");

RandomAccessFile raf = RandomAccessFile(file,"rw");

raf.writeUTF("asdjasdfkl aihf oh asd ");

raf.seek(0);

String str = raf.readUTF();

System.out.println(str);


读取文件是游标 

RandomAccessFile raf =new RandoAccessFile(file,"rw");

raf.seek(0);

输出游标位置

raf.getFilePointer()




从一个文件中读一个字节并写入到第二个文件中 ==》复制文件

创建一个File 对象用于描述要复制的文件

并用一个RandomAccessFile 读取

在创建一个新的File对象描述复制后的文件

并再用一个RandomAccessFile 写入数据

int data = -1;

while((data = src.read())!=-1){

 desRaf.write(data);

}




使用缓冲的方式复制

创建应给File对象用于描述要复制的文件

并用一个RandomAccessFile 读取

在创建应给新的File对象描述复制后的文件

并再用一个RandomAccessFile写入数据。不过这里使用数组的方式写入

byte[] buf = new byte[1024 * 10];

ine len =0;

while((len = srcRaf.read(buf))>0){

 desRaf.write(buf,0,len);

}



Java中的IO

输入流与输出流


InputStream

输入流

 用于从外界读取数据到程序中

OutputStream

输出流

 用于将程序中的数据发送到外界

对于程序

进入程序的是Input  读入

从程序出去的Output  写出


java中的流分为

低级流:节点流

    数据的来源和去向是明确的


高级流:处理流,过滤流

    高级流不能独立存在,通常基于一个流进行工作,使用高级流可以简化我们的读写操作



根据读写数据的单位通常划分为

字节流

    以字节为单位读写数据

字符流

    以字符为单位读写数据



java.io中输入流和输出流的父类


java.io.InputStream

    这是一个抽象类,不能实例化,是所有输入流的父类

        其中定义了读取数据的相关方法


java.io.OutputStream

    这是一个抽象类,不能实例化,是所有输出流的父类

        其中定义饿了写出数据的相关方法


FIS 与FOS

文件字节输入输出流


FileInputStream

用于读取文件的字节流

File file = new File("xxxx");

FileInputStream fis = new FileInputStream(file);

fis.read();

FileOutpputStream 


用于向文件写数据的字节流

FileOutputStream fos = new FileOutputStream("xxxxx");

fos.write();


向文件中追加内容

File file = new File("xxxxx");

RandomAccessFile raf = new RandomAccessFile(file,"rw");

raf.seek(file.length());

raf.writeUTF("hihihihihihihihihihihiihihihi");

raf.close();


使用流的时候  就是后面添加一个true   就是在文件中追加内容,只要使用这个流就是追加

FileOutputStream fos = new FileOutputStream("20160722-2",true);

String str = "123123123123";

byte[] data = str.getBytes("UTF-8");

fos.write(data);

fos.close();


具有缓冲功能的输出流  是高级流

加快了读写效率


BIS 和BOS

BufferedInputStream 

缓冲字节输入流


File file = new File("xxxxxx");

FileInputStream fis = new FileInputStream(file);

BufferedInputStream bis = new BufferedInputStream(fis);

bis.read();


BuffedOutputStream

缓冲字节输出流


FileOutputStream fos = new FileOutputStream("xxxx");

BufferedOutputStream bos = new BufferedOutputStream(fos);

bos.write();


强制刷新

bos.flush();


将一个数据转化为对应的字节

这个过程 =》 序列化

将数据写入硬盘做长久保存的过程 =》 数据持久化

将字节转换为数据的过程 反序列化



用于读写基本类型数据的流  8个基本



DataInputStream

File file = new File("xxxx");

FileInputStream fis = new FileInputStream(file);

DataInputStream dis = new DataInputStream(fis);


DataOutputStream

FileOutputStream fos = new FileOutputStream("xxxxx");

DataOutputStream dos = new DataOutputStream(fos);

dos.writeInt(123);

dos.writeChar('a');

dos.writeUTF("123123");

dos.writeDouble(123.123);






字符流

读写以字符为单位

字符流的父类

java.io.Reader

java.io.Writer


读写数据都是基于字节的,所已字符流都是高级流


文本信息


子类实现

InputStreamReader


File file = new File("xxx");

FileInputStream fis = new FileInputStream(file);

InputStreamReader reader = new InputStreamReader(fis);

int c = -1;

while((c=reader.read()) != -1){

System.out.println((char)c);

}

reader.close();

连续读取2个字节(1个字符),并以int 形式返回

所以该int值低16位有数据

若返回值为-1 表示EOF


OutputStreamWriter


FileOutputStream fos = new FileOutputStream("xxxx");

OutputStreamWriter writer = new OutputStreamWriter(fos);

writer.writer('A');

char[] chs = {'1','2','3','4','5'};

writer.writer(chs,2,3);

writer.close();

package se.day001;import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;public class Demo42 {public static void main(String[] args) throws Exception{File srcFile = new File("."+File.separator+"src"+File.separator+"se"+File.separator+"day001"+File.separator+"Demo40.java");FileInputStream fis = new FileInputStream(srcFile);InputStreamReader reader = new InputStreamReader(fis);File desFile = new File("20160725-5");FileOutputStream fos = new FileOutputStream(desFile);OutputStreamWriter writer = new OutputStreamWriter(fos);char[] chs = new char[1024*5];int len = -1;while((len = reader.read(chs)) > 0){writer.write(chs,0,len);}reader.close();writer.close();}
}



缓冲字符输入输出流

 以行为单位读写字符


BufferedReader

缓冲字符输入流

 br.readLine()  一次读一行字符

    连续读取字符,知道去读到换行符为止,然后将换行符之前的字符组成字符串返回

    返回值中是不包含换行符的

    当返回值为null时表示EOF

BufferedWriter

缓冲字符输出流

 bw.write(str);

 bw.newLine();  换行 就用这个 跨平台


穿重字符输入流质处理字符输入流

所以要先将细节输入流包装为字符输入流

package se.day001;import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;public class Demo43 {public static void main(String[] args) throws Exception{File srcFile  = new File("."+File.separator+"src"+File.separator+"se"+File.separator+"day001"+File.separator+"Demo40.java");FileInputStream fis = new FileInputStream(srcFile);InputStreamReader reader = new InputStreamReader(fis);BufferedReader br = new BufferedReader(reader);FileOutputStream fos = new FileOutputStream("20160725-7");OutputStreamWriter writer = new OutputStreamWriter(fos);BufferedWriter bw = new BufferedWriter(writer);String str = null;while((str= br.readLine())!=null){bw.write(str);bw.newLine();}br.close();bw.close();}
}



用于读取文本文件的字符流

读取文本的时候使用系统默认的编码集,不能设置编码集,解决方法,不使用这个

使用InputStreamReader读取

FileReader

文件字符输入流

FileWriter

文件字符输出流



InputStreamReader 有一个重载的构造方法支持指定特殊的编码集读取文本文件

InputStreamReader(FileInputStream file,String charset)

package se.day001;import java.io.FileOutputStream;
import java.io.UnsupportedEncodingException;public class Demo45 {public static void main(String[] args) throws Exception{String str = "哈哈哈哈哈哈哈哈哈 ?";FileOutputStream fos = new FileOutputStream("20160725-9");byte[] data = str.getBytes("UTF-8");fos.write(data);fos.close();}
}
package se.day001;import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;public class Demo47 {public static void main(String[] args) throws IOException{FileInputStream fis = new FileInputStream("20160725-9");InputStreamReader inReader = new InputStreamReader(fis,"UTF-8");int chr = -1;while((chr = inReader.read())!=-1){System.out.print((char)chr);}inReader.close();}
}





PrintWriter

带自动刷新的缓冲字符输出流


常用的构造方法

PrintWriter(File file)

创建一个像给定文件写数据的PrintWriter

创建一个不自动行刷新的流


PrintWriter(OutputStream out)

创建一个不具备自动行刷新的基于给定字节输出流尽心写操作的PrintWriter


PrintWriter(OutputStream out,boolean autoFlush)

创建一个具备自动行刷新的基于给定字节输出流进行写操作的PrintWriter


字符

PrintWriter(Writer w)


PrintWriter(Writer w,boolean autoFlush)


PrintWriter(String FilePath)

根据给定的文件路径,创建基于该文件进行写操作的PrintWriter

package se.day001;import java.io.PrintWriter;public class Demo48 {public static void main(String[] args)throws Exception{PrintWriter pw = new  PrintWriter("pw20160725");pw.println("随便写点什么东西,给你看看吧");pw.println("再来一点东西,快看");pw.close();}
}
package se.day001;import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;public class Demo49 {public static void main(String[] args) throws FileNotFoundException{File file = new File("file20150725");PrintWriter pw = new PrintWriter(file);pw.println("哈哈哈哈哈哈哈");pw.println("在来一发");pw.close();}
}
package se.day001;import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;public class Demo49 {public static void main(String[] args) throws FileNotFoundException{FileOutputStream out = new FileOutputStream("pw201607252.txt");PrintWriter pw = new PrintWriter(out);pw.println("和吱吱吱吱吱吱");pw.println("快了快了快了快了");pw.close();}
}
package se.day001;import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;public class Demo49 {public static void main(String[] args) throws FileNotFoundException{FileOutputStream out = new FileOutputStream("pw201607253.txt");PrintWriter pw = new PrintWriter(out,true);pw.println("和吱吱吱吱吱吱");pw.println("快了快了快了快了");}
}


写LOG的简单方法:

package se.day001;import java.io.File;
import java.io.PrintStream;public class Demo50 {public static void main(String[] args) throws Exception{System.out.println("HelloWorld");File file = new File("20160726.log");PrintStream ps = new PrintStream(file);ps.println(" write in file");//保存针对控制台的输出流PrintStream out = System.out;//将创建的输出流设置给SystemSystem.setOut(ps);System.out.println(" i come ");//还原原来的输出流System.setOut(out);ps.close();}
}

简单的控制台输入

package se.day001;import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;public class Demo51 {public	static void main(String[] args)throws Exception{InputStream in = System.in;//想读取字符串,就先将其转为字符输入流InputStreamReader reader = new InputStreamReader(in);//转换为可以按行读取的缓冲字符输入流BufferedReader br = new BufferedReader(reader);String str = null;//readLine() 方法会卡住,直到输入回车,才会将之前输入的内容//作为一个字符串返回//键盘数据是源源不断的,不像文件有尽头,所以//while循环是永远不会停的while((str = br.readLine()) != null){if("exit".equals(str)){System.out.println("bye");break;}System.out.println("输入的是:"+str);}}
}


命令行 记事本

package se.day001;import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;public class Demo51 {public	static void main(String[] args)throws Exception{InputStream in = System.in;//想读取字符串,就先将其转为字符输入流InputStreamReader reader = new InputStreamReader(in);//转换为可以按行读取的缓冲字符输入流BufferedReader br = new BufferedReader(reader);FileOutputStream fos = new FileOutputStream("20160726-1.log");PrintWriter pw = new PrintWriter(fos,true);String str = null;//readLine() 方法会卡住,直到输入回车,才会将之前输入的内容//作为一个字符串返回//键盘数据是源源不断的,不像文件有尽头,所以//while循环是永远不会停的while((str = br.readLine()) != null){if("exit".equals(str)){System.out.println("bye");break;}pw.println(str);}pw.close();br.close();}
}



可以对 对象 进行序列化与反序列化的流


ObjectInputStream

读取字节并转换为对象输入流(反序列化)

ObjectOutputStream

将对象转换为字节后并写出的流(序列化)

需要序列化的类需要实现这个接口,这个接口就是一个标记

implements Serializable

当摸个属性被transient 修饰,那么该属性在序列化过程中被忽略

在反序列化时得不到原来的值

private transient int sex;
package se.day001;import java.io.Serializable;public class Person implements Serializable{private String name;private int age;private transient int sex;public Person(String name,int age,int sex) {this.name = name;this.age = age;this.sex = sex;}public void setName(String name){this.name = name;}public void setAge(int age){this.age = age;}public void setSex(int sex){this.sex = sex;}public String getName(){return name;}public int getAge(){return age;}public int getSex(){return sex;}
}
package se.day001;import java.io.FileOutputStream;
import java.io.ObjectOutputStream;public class Dem052 {public static void main(String[] args) throws Exception {Person p = new Person("lmdtx", 18, 1);//创建写文件的字节输出流FileOutputStream fos = new FileOutputStream("person20160726");//创建可以序列化对象输出流ObjectOutputStream oos = new ObjectOutputStream(fos);//将给定的Person对象序列化后写入文件中oos.writeObject(p);oos.close();}
}
package se.day001;import java.io.FileInputStream;
import java.io.ObjectInputStream;public class Demo53 {public static void main(String[] args)throws Exception{//创建用于读取保存着对象字节的文件的输入流FileInputStream fis = new FileInputStream("person20160726");ObjectInputStream ois = new ObjectInputStream(fis);Person p = (Person)ois.readObject();System.out.println(p.getName());System.out.println(p.getAge());System.out.println(p.getSex());ois.close();}
}

java语言的一个优势就是处理多线程比较简单


每一个程序都是 I C O


输入 I

计算 C

输出 O


一般操作系统都支持同时执行多个程序,那么每个同事运行的程序对操作系统而言称为一个进程

而对于一个程序而言,内部也可能同时运行多个任务,那么每个同时运行的任务称为一个线程


无论是进程还是线程,任务都是并发运行的,而不是纯粹的同时运行 具体的看操作系统原理


创建线程的步骤

定义一个类,并继承Thread类

Thread类是线程类,七种定义这操作线程的相关方法

重写run方法,该方法中应该定义的内容就是要并发运行的代码

实例化线程并启动

(有一个弊端,就是定义线程的时候就决定该线程要运行的任务,尽可能避免线程与执行的任务关联性太强)


并发的执行过程

当一个线程条用了start() 方法,该线程纳入线程调度机制,得以并发运行


package se.day001;public class Demo55 {public static void main(String[] args){Thread t1 = new Person1();Thread t2 = new Person2();//启动线程不能去调用run方法,而是要调用start()方法//否则两个线程不是并发运行的t1.start();t2.start();}
}class Person1 extends Thread{public void run(){for(int i = 0;i<1000;i++){System.out.println("who are you? count:"+i);}}
}class Person2 extends Thread{public void run(){for(int i = 0;i<1000;i++){System.out.println("I am xxx count:"+i);}}
}


任务是任务,线程是线程,线程只关心可并发运行即可,给什么任务就并发运行什么任务


package se.day001;public class Demo56 {public static void main(String[] args){Runnable p3 = new Person3();Runnable p4 = new Person4();Thread t3 = new Thread(p3);Thread t4 = new Thread(p4);t3.start();t4.start();}
}
/*** 定义一个类并实现Runnable接口并重写run方法* run方法中定义线程中药执行的代码*/
class Person3 implements Runnable{public void run(){for(int i = 0;i<1000;i++){System.out.println("who are you? count:"+i);}}
}class Person4 implements Runnable{public void run(){for(int i = 0 ;i<1000;i++){System.out.println("I am xxx count:"+i);}}
}
package se.day001;
/*** 匿名的方式创建线程 **/
public class Demo57 {public static void main(String[] args){Thread t5 = new Thread(){public void run(){System.out.println("one");}};Thread t6 = new Thread(new Runnable(){public void run(){System.out.println("two");}});t5.start();t6.start();}
}

 

线程中常用的方法

static void sleep(long time)

让当前线程进入睡眠阻塞time 毫秒,当时间消耗完毕后,线程重写回到runnable

Thread.sleep(1000);


void interrupt()

中断线程


返回当前运行的线程 谁调用它,它返回谁

Thread.currentThread();


用于获取当前线程的名字,这个名字是系统分配的

也可以自己定义

getName()


一个方法的局部内部类中要引用该方法的 其他局部变量那么这个变量必须是final的

package se.day001;public class Demo59 {public static void main(String[] args){final Thread l = new Thread(new Runnable(){public void run(){System.out.println("zzzzzzz");try {Thread.sleep(1000000);} catch (InterruptedException e) {System.out.println("狗蛋,别闹");//e.printStackTrace();}}});Thread h = new Thread(new Runnable(){public void run(){System.out.println("老大,别睡了");for(int i = 0;i<5;i++){System.out.println("有妹子");try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("妹子都要走了");l.interrupt();}});l.start();h.start();}
}


设置优先级

final void setPriority(int p)

1-10

有对应的常量

MAX_PRIORITY 10

NORM_PRIORITY 5

MIN_PRIORITY 1

每一个线程都会分配一个优先级NORM_PRIORITY



守护线程(后台线程)

当一个进程中所有前台线程运行完毕后,所有后台线程均要强制结束


进程的结束

当一个进程中的所有线程结束后,该进程结束


设置后台线程的方法要在该线程启动前调用

t1.setDaemon(true);


线程安全问题:

 当多想成访问同一段数据时,机会引发现场安全问题

需要在访问数据的地方保证同步操作,就是要由先后顺序,不能同时访问

synchronized 同步锁

当synchronized 关键字修饰方法时,该方法变成同步方法,多个线程不能同时执行该方法

当修饰方法时,那么锁对象就当前对象,就是给this 上了个锁

当一个类中声明的多个方法均被synchronized 修饰,那么这些方法是互斥关系,同一个时间不可能被同事调用

如果所有的操作均都对方法进行同步,显然效率底下,在方法中,有时只有部分代码需要同步,这时候我们只需要同步这部分就好了,这样可以提高同步效率

synchronized(同步监视器){


}


同步监视器就是要上锁的对象

通常使用的同步监视器(上锁的对象)是this

要保证需要同步的代码库上锁的对象多个线程都能够看到,才可以保证同步

package se.day001;public class Demo63 {public static void main(String[] args){final Shop shop = new Shop();Runnable runnable =new Runnable(){public void run(){shop.bygGoods();}};//创建 三个线程,同时调用bygGoods()方法Thread t1 =new Thread(runnable);Thread t2 =new Thread(runnable);Thread t3 =new Thread(runnable);t1.start();t2.start();t3.start();	}
}class  Shop{public void bygGoods(){System.out.println("tiao yifu");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}synchronized (this) {System.out.println("tiao hao le ,shishi yifu");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("jie zhang zou ren ");}
}



线程安全 与 不安全的类


StringBuffer(安全)

StringBuilder(不安全)


Vector(安全)

ArrayList(不安全)


Hashtable(安全)

HashMap(不安全)


所有的集合都支持一个以参数为Collection的构造方法

这个构造方法的作用可以在创建当前集合的基础上,将给定的集合元素放入其中,这个构造方法通常习惯叫他为:集合的复制构造器


List list = new ArrayList();

list.append("1");

list.append("2");

list.append("3");

List vector = new Vector(list);

使用Collections 的方法,可以方便的将一个集合变成线程安全的

List syncList = Collections.synchronizedList(list);

set

set syncSet = Collections.synchronizedSet(hashset);

map

Map<String,Integer> syncMap = Collections.synchronizedMap(map);



很多应用中都需要使用多线程,

当一个线程要完成的工作需要基于另一个线程的工作情况时,我们则需要两个线程协调工作


在Object 中 定义的:

wait() 在当前线程上等待

 通过调用一个对象的wait()方法后,那么这个线程就在当前线程上等待,进入了等待阻塞

他和sleep 的区别在于

    sleep() 阻塞会在指定时间消耗完毕后自动回到runnable状态

    wait() 阻塞则不会自动回到runnable 直到调用了这个对象的notify方法,当前线程才回到runnable状态

    wait() 在谁身上等,就要锁谁  synchronized(){}


notify() 通知一个在当前线程上等待的线程运行

    this.notify() 通知在他身上等待的的解除等待阻塞

    也是要加锁的 synchrized(this){}

notifyAll() 一个对象身上可以有多个对象在等待  notify() 只能随机的唤醒一个

如果要所有的都唤醒 就使用notifyAll()


package se.day001;public class Demo64 {public static boolean finish = false;public static void main(String[] args){final Thread downThread = new Thread(new Runnable(){public void run(){for(int i = 0;i<100;i++){System.out.println(i+"%");try {Thread.sleep(500);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}System.out.println("下载完成");finish = true;synchronized (this) {this.notify();}}});Thread displayThread = new Thread(new Runnable(){public void run(){System.out.println("等待下载图片的线程通知");try {synchronized (downThread) {downThread.wait();}} catch (InterruptedException e) {e.printStackTrace();}if(!finish){throw new RuntimeException("图片没有下载完毕,无法显示图片");}System.out.println("显示");}});downThread.start();displayThread.start();}
}



线程池

 使用 线程池

 ExecutorService 实现线程池

  是java 提供的用于管理线程池的类

  作用

   控制线程数量

   重用线程

  当一个程序中若创建大量线程,病在任务结束后销毁 会给系统带来过度的消耗资源,以及过度切换线程德危险 从而可能导致系统崩溃为此我们应该使用线程池来解决这个问题

 

 Executors.newCachedThreadPool()

创建一个可根据需要穿创建新线程的线程池,但是在以前构造的线程可用时将重用他们

弹性比较好,可以 满足 瞬间 激增的  有宕机的风险

 Executors.newFixedThreadPool(int nThreads)

创建一个可重用固定线程集合的线程池,以共享的***队列方式来运行这些线程

 Executors.newScheduledThreadPool(int corePoolSize)

创建一个线程池,他可安排在给定延迟够运行命令或者定期的执行

 Executors.newSingleThreadExecutor()

创建一个使用单个worker 线程德Executor 以***队列方法来运行该线程

单线程模式  等于  Executors.newFixedThreadPool(1)

 

 

public class Demo65 {public static void main(String[] args) {ExecutorService threadPool = Executors.newFixedThreadPool(2);for(int i = 0;i<10;i++){Runnable runn = new Runnable(){public void run(){for(int i = 0;i<10;i++){System.out.println(i);try {Thread.sleep(500);} catch (InterruptedException e) {}}}};threadPool.execute(runn);}}}

 

 

 




网络基础


java网络开发

Socket套接字

网络应用的模式


C/S 客户端对服务器端

客户端都是根据需要制定的有特定的传输协议

可以为用户提供更准确的需要,更好的效果,

但是对于更新和维护来讲,需要影响用户所以维护和更新是弊端


B/S 浏览器对服务器端

通信协议一致的特殊C/S结构应用




服务端创建一个

ServerSocket 服务器端套接字

    调用accept()方法来等待客户端来连接

客户端 创建一个Socket 请求与服务端建立连接

Socket

服务端接收客户端的连接请求,同时创建一个新的Socket与客户端建立连接,服务端继续等待新的请求
























这篇关于Java100:javaSE备忘的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1134228

相关文章

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时,有没有考虑过 JVM 是如何把静态的字节码(byte code)转化为运行时对象的呢,这个问题看似简单,但清楚的同学相信也不会太多,这篇文章首先介绍 JVM 类初始化的机制,然后给出几个易出错的实例来分析,帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段,分别是:loading 、Linking、initialization

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权,允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true (Spring security默认会带有ROLE_前缀),去

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程,特意画了如下的类图,包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口,接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类,它们之间的依赖,构建起了整个框架。想要理解整个架构,最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文(security context)的信息。当前操作的用户是谁,该用户是否已经被认证,他拥有哪些角色权限…这些都被保

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明(认真看哦) AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证,则会调用 #attemptAuthentica

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门(一):登录与退出》 《Spring-Security-入门(二):基于数据库验证》 《Spring-Security-入门(三):密码加密》 《Spring-Security-入门(四):自定义-Filter》 《Spring-Security-入门(五):在 Sprin

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来,一站式有声阅读平台听书系统 🌟&nbsp;开篇:遇见未来,从“智听”开始 在这个快节奏的时代,你是否渴望在忙碌的间隙,找到一片属于自己的宁静角落?是否梦想着能随时随地,沉浸在知识的海洋,或是故事的奇幻世界里?今天,就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统,它正悄悄改变着我们的阅读方式,让未来触手可及! 📚&nbsp;第一站:海量资源,应有尽有 走进“智听

在cscode中通过maven创建java项目

在cscode中创建java项目 可以通过博客完成maven的导入 建立maven项目 使用快捷键 Ctrl + Shift + P 建立一个 Maven 项目 1 Ctrl + Shift + P 打开输入框2 输入 "> java create"3 选择 maven4 选择 No Archetype5 输入 域名6 输入项目名称7 建立一个文件目录存放项目,文件名一般为项目名8 确定