【HuoLe的面试凉经】

Java基础

1. JRE和JDK的区别

  • 定义

**JRE(Java Runtime Enviroment)**是Java的运行环境。面向Java程序的使用者,而不是开发者。如果你仅下载并安装了JRE,那么你的系统只能运行Java程序。JRE是运行Java程序所必须环境的集合,包含JVM标准实现及 Java核心类库。它包括Java虚拟机、Java平台核心类和支持文件。它不包含开发工具(编译器、调试器等)。

**JDK(Java Development Kit)**又称J2SDK(Java2 Software Development Kit),是Java开发工具包,它提供了Java的开发环境(提供了编译器javac等工具,用于将java文件编译为class文件)和运行环境(提 供了JVM和Runtime辅助包,用于解析class文件使其得到运行)。如果你下载并安装了JDK,那么你不仅可以开发Java程序,也同时拥有了运 行Java程序的平台。JDK是整个Java的核心,包括了Java运行环境(JRE),一堆Java工具tools.jar和Java标准类库 (rt.jar)。

  • 区别

JRE主要包含:java类库的class文件(都在lib目录下打包成了jar)和虚拟机(jvm.dll);JDK主要包含:java类库的 class文件(都在lib目录下打包成了jar)并自带一个JRE。那么为什么JDK要自带一个JRE呢?而且jdk/jre/bin下的client 和server两个文件夹下都包含jvm.dll(说明JDK自带的JRE有两个虚拟机)。

2. Java中equals()和==的区别

equals是判断两个变量或者实例指向同一个内存空间的值是不是相同

而**==**是判断两个变量或者实例是不是指向同一个内存空间

java中的数据类型,可分为两类:
1.基本数据类型,也称原始数据类型。byte,short,char,int,long,float,double,boolean
他们之间的比较,应用双等号(),比较的是他们的值。
2.复合数据类型(类)
当他们用(
)进行比较的时候,比较的是他们在内存中的存放地址,所以,除非是同一个new出来的对象,他们的比较后的结果为true,否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的,在Object中的基类中定义了一个equals的方法,这个方法的初始行为是比较对象的内存地 址,但在一些类库当中这个方法被覆盖掉了,如String,Integer,Date在这些类当中equals有其自身的实现,而不再是比较类在堆内存中的存放地址了。
对于复合数据类型之间进行equals比较,在没有覆写equals方法的情况下,他们之间的比较还是基于他们在内存中的存放位置的地址值的,因为Object的equals方法也是用双等号()进行比较的,所以比较后的结果跟双等号()的结果相同。

3. 两个对象的hashCode相同,则equals也一定为true么

首先,答案肯定是不一定。同时反过来equals为true,hashCode也不一定相同。

类的hashCode方法和equals方法都可以重写,返回的值完全在于自己定义。

hashCode()返回该对象的哈希码值;equals()返回两个对象是否相等。

关于hashCode和equal是方法是有一些 常规协定 :

1、两个对象用equals()比较返回true,那么两个对象的hashCode()方法必须返回相同的结果。

2、两个对象用equals()比较返回false,不要求hashCode()方法也一定返回不同的值,但是最好返回不同值,以提搞哈希表性能。

3、重写equals()方法,必须重写hashCode()方法,以保证equals方法相等时两个对象hashcode返回相同的值。

4. java中的final关键字

final关键字可以用来修饰引用、方法和类。

  • 用来修饰一个引用
  1. 如果引用为基本数据类型,则该引用为常量,该值无法修改;
  2. 如果引用为引用数据类型,比如对象、数组,则该对象、数组本身可以修改,但指向该对象或数组的地址的引用不能修改。
  3. 如果引用时类的成员变量,则必须当场赋值,否则编译会报错。
  • 用来修饰一个方法

    当使用final修饰方法时,这个方法将成为最终方法,无法被子类重写。但是,该方法仍然可以被继承。

  • 用来修饰类

当用final修改类时,该类成为最终类,无法被继承。简称为“断子绝孙类”。

5. java 中操作字符串都有哪些类?它们之间有什么区别?

主要是一下三种:String、StringBuffer、StringBuilder

String和StringBuilder和StringBuffer的区别

StringStringBufferStringBuilder
String的值是不可变的,这就导致每次对String的操作都会生成新的String对象,不仅效率低下,而且浪费大量优先的内存空间StringBuffer是可变类,和线程安全的字符串操作类,任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量,当字符串大小没有超过容量时,不会分配新的容量,当字符串大小超过容量时,会自动增加容量可变类,速度更快
不可变可变可变
线程安全线程不安全
多线程操作字符串单线程操作字符串
1. 线程安全
  • StringBuffer:线程安全,StringBuilder:线程不安全。因为 StringBuffer 的所有公开方法都是 synchronized 修饰的,而 StringBuilder 并没有 synchronized修饰。
2. 缓存
  • StringBuffer 每次获取 toString 都会直接使用缓存区的 toStringCache 值来构造一个字符串。

    而 StringBuilder 则每次都需要复制一次字符数组,再构造一个字符串。

    所以,缓存冲这也是对 StringBuffer 的一个优化吧,不过 StringBuffer 的这个toString 方法仍然是同步的。

3.性能
  • 既然 StringBuffer 是线程安全的,它的所有公开方法都是同步的,StringBuilder 是没有对方法加锁同步的,所以毫无疑问,StringBuilder 的性能要远大于 StringBuffer。

所以,StringBuffer 适用于用在多线程操作同大量数据的场景,如果是单线程操作大量数据场合 StringBuilder 更适合。

6. String str = “i” 与 String str = new String(“i”)一样吗?

**不一样,因为内存的分配方式不一样。**String str = "i"的方式,Java虚拟机会将其分配到常量池中;而String str = new String(“i”)则会被分到堆内存中。

String str=“i”; 因为String 是final类型的,所以“i”应该是在常量池。

而new String(“i”);则是新建对象放到堆内存中。

7. Java如何将字符串反转

1. 利用 StringBuffer 或 StringBuilder 的 reverse 成员方法:

  // StringBuffer
  public static String reverse1(String str) {
    return new StringBuilder(str).reverse().toString();
  }

2. 利用 String 的 toCharArray 方法先将字符串转化为 char 类型数组,然后将各个字符进行重新拼接:

  // toCharArray
  public static String reverse2(String str) {
    char[] chars = str.toCharArray();
    String reverse = "";
    for (int i = chars.length - 1; i >= 0; i--) {
      reverse += chars[i];
    }
    return reverse;
  }

3. 利用 String 的 CharAt 方法取出字符串中的各个字符:

  // charAt
  public static String reverse3(String str) {
    String reverse = "";
    int length = str.length();
    for (int i = 0; i < length; i++) {
      reverse = str.charAt(i) + reverse;
    }
    return reverse;
  }

8. Java-String类的常用方法总结

一、String类
String类在java.lang包中,java使用String类创建一个字符串变量,字符串变量属于对象。java把String类声明的final类,不能有类。String类对象创建后不能修改,由0或多个字符组成,包含在一对双引号之间。
二、String类对象的创建
字符串声明:String stringName;
字符串创建:stringName = new String(字符串常量);或stringName = 字符串常量;
三、String类构造方法
1、public String()
无参构造方法,用来创建空字符串的String对象。
1 String str1 = new String();
2、public String(String value)
用已知的字符串value创建一个String对象。
1 String str2 = new String(“asdf”); 2 String str3 = new String(str2);
3、public String(char[] value)
用字符数组value创建一个String对象。

1 char[] value = {'a','b','c','d'};
2 String str4 = new String(value);//相当于String str4 = new String("abcd");

4、public String(char chars[], int startIndex, int numChars)
用字符数组chars的startIndex开始的numChars个字符创建一个String对象。

1 char[] value = {'a','b','c','d'};
2 String str5 = new String(value, 1, 2);//相当于String str5 = new String("bc");

5、public String(byte[] values)
用比特数组values创建一个String对象。

1 byte[] strb = new byte[]{65,66};
2 String str6 = new String(strb);//相当于String str6 = new String("AB");

四、String类常用方法
1、求字符串长度
public int length()//返回该字符串的长度

1 String str = new String("asdfzxc");
2 int strlength = str.length();//strlength = 7

2、求字符串某一位置字符
public char charAt(int index)//返回字符串中指定位置的字符;注意字符串中第一个字符索引是0,最后一个是length()-1。

1 String str = new String("asdfzxc");
2 char ch = str.charAt(4);//ch = z

3、提取子串
用String类的substring方法可以提取字符串中的子串,该方法有两种常用参数:
1)public String substring(int beginIndex)//该方法从beginIndex位置起,从当前字符串中取出剩余的字符作为一个新的字符串返回。
2)public String substring(int beginIndex, int endIndex)//该方法从beginIndex位置起,从当前字符串中取出到endIndex-1位置的字符作为一个新的字符串返回。

1 String str1 = new String("asdfzxc");
2 String str2 = str1.substring(2);//str2 = "dfzxc"
3 String str3 = str1.substring(2,5);//str3 = "dfz"

4、字符串比较
1)public int compareTo(String anotherString)//该方法是对字符串内容按字典顺序进行大小比较,通过返回的整数值指明当前字符串与参数字符串的大小关系。若当前对象比参数大则返回正整数,反之返回负整数,相等返回0。
2)public int compareToIgnore(String anotherString)//与compareTo方法相似,但忽略大小写。
3)public boolean equals(Object anotherObject)//比较当前字符串和参数字符串,在两个字符串相等的时候返回true,否则返回false。
4)public boolean equalsIgnoreCase(String anotherString)//与equals方法相似,但忽略大小写。

1 String str1 = new String("abc");
2 String str2 = new String("ABC");
3 int a = str1.compareTo(str2);//a>0
4 int b = str1.compareToIgnoreCase(str2);//b=0
5 boolean c = str1.equals(str2);//c=false
6 boolean d = str1.equalsIgnoreCase(str2);//d=true

5、字符串连接
public String concat(String str)//将参数中的字符串str连接到当前字符串的后面,效果等价于"+"。

1 String str = "aa".concat("bb").concat("cc");
2 相当于String str = "aa"+"bb"+"cc";

6、字符串中单个字符查找
1)public int indexOf(int ch/String str)//用于查找当前字符串中字符或子串,返回字符或子串在当前字符串中从左边起首次出现的位置,若没有出现则返回-1。
2)public int indexOf(int ch/String str, int fromIndex)//改方法与第一种类似,区别在于该方法从fromIndex位置向后查找。
3)public int lastIndexOf(int ch/String str)//该方法与第一种类似,区别在于该方法从字符串的末尾位置向前查找。
4)public int lastIndexOf(int ch/String str, int fromIndex)//该方法与第二种方法类似,区别于该方法从fromIndex位置向前查找。

1 String str = "I am a good student";
2 int a = str.indexOf('a');//a = 2
3 int b = str.indexOf("good");//b = 7
4 int c = str.indexOf("w",2);//c = -1
5 int d = str.lastIndexOf("a");//d = 5
6 int e = str.lastIndexOf("a",3);//e = 2

7、字符串中字符的大小写转换
1)public String toLowerCase()//返回将当前字符串中所有字符转换成小写后的新串
2)public String toUpperCase()//返回将当前字符串中所有字符转换成大写后的新串

1 String str = new String("asDF");
2 String str1 = str.toLowerCase();//str1 = "asdf"
3 String str2 = str.toUpperCase();//str2 = "ASDF"

8、字符串中字符的替换
1)public String replace(char oldChar, char newChar)//用字符newChar替换当前字符串中所有的oldChar字符,并返回一个新的字符串。
2)public String replaceFirst(String regex, String replacement)//该方法用字符replacement的内容替换当前字符串中遇到的第一个和字符串regex相匹配的子串,应将新的字符串返回。
3)public String replaceAll(String regex, String replacement)//该方法用字符replacement的内容替换当前字符串中遇到的所有和字符串regex相匹配的子串,应将新的字符串返回。

1 String str = "asdzxcasd";
2 String str1 = str.replace('a','g');//str1 = "gsdzxcgsd"
3 String str2 = str.replace("asd","fgh");//str2 = "fghzxcfgh"
4 String str3 = str.replaceFirst("asd","fgh");//str3 = "fghzxcasd"
5 String str4 = str.replaceAll("asd","fgh");//str4 = "fghzxcfgh"

9、其他类方法
1)String trim()//截去字符串两端的空格,但对于中间的空格不处理。

1 String str = " a sd ";
2 String str1 = str.trim();
3 int a = str.length();//a = 6
4 int b = str1.length();//b = 4

2)boolean statWith(String prefix)boolean endWith(String suffix)//用来比较当前字符串的起始字符或子字符串prefix和终止字符或子字符串suffix是否和当前字符串相同,重载方法中同时还可以指定比较的开始位置offset。

1 String str = "asdfgh";
2 boolean a = str.statWith("as");//a = true
3 boolean b = str.endWith("gh");//b = true

3)regionMatches(boolean b, int firstStart, String other, int otherStart, int length)//从当前字符串的firstStart位置开始比较,取长度为length的一个子字符串,other字符串从otherStart位置开始,指定另外一个长度为length的字符串,两字符串比较,当b为true时字符串不区分大小写。
4)contains(String str)//判断参数s是否被包含在字符串中,并返回一个布尔类型的值。

1 String str = "student";
2 str.contains("stu");//true
3 str.contains("ok");//false

5)String[] split(String str)//将str作为分隔符进行字符串分解,分解后的字字符串在字符串数组中返回。

1 String str = "asd!qwe|zxc#";
2 String[] str1 = str.split("!|#");//str1[0] = "asd";str1[1] = "qwe";str1[2] = "zxc";

五、字符串与基本类型的转换
1、字符串转换为基本类型
java.lang包中有Byte、Short、Integer、Float、Double类的调用方法:
1)public static byte parseByte(String s)
2)public static short parseShort(String s)
3)public static short parseInt(String s)
4)public static long parseLong(String s)
5)public static float parseFloat(String s)
6)public static double parseDouble(String s)
例如:

1 int n = Integer.parseInt("12");
2 float f = Float.parseFloat("12.34");
3 double d = Double.parseDouble("1.124");

2、基本类型转换为字符串类型
String类中提供了String valueOf()放法,用作基本类型转换为字符串类型。
1)static String valueOf(char data[])
2)static String valueOf(char data[], int offset, int count)
3)static String valueOf(boolean b)
4)static String valueOf(char c)
5)static String valueOf(int i)
6)static String valueOf(long l)
7)static String valueOf(float f)
8)static String valueOf(double d)
例如:

1 String s1 = String.valueOf(12);
2 String s1 = String.valueOf(12.34);

3、进制转换
使用Long类中的方法得到整数之间的各种进制转换的方法:
Long.toBinaryString(long l)
Long.toOctalString(long l)
Long.toHexString(long l)
Long.toString(long l, int p)//p作为任意进制

9. 抽象类必须要有抽象方法吗?

答:不需要,

抽象类不一定有抽象方法;但是包含一个抽象方法的类一定是抽象类。(有抽象方法就是抽象类,是抽象类可以没有抽象方法)

解释:

抽象方法:

java中的抽象方法就是以abstract修饰的方法,这种方法只声明返回的数据类型、方法名称和所需的参数,没有方法体,也就是说抽象方法只需要声明而不需要实现。

抽象方法与抽象类:

当一个方法为抽象方法时,意味着这个方法必须被子类的方法所重写,否则其子类的该方法仍然是abstract的,而这个子类也必须是抽象的,即声明为abstract。abstract抽象类不能用new实例化对象,abstract方法只允许声明不能实现。如果一个类中含有abstract方法,那么这个类必须用abstract来修饰,当然abstract类也可以没有abstract方法。 一个抽象类里面没有一个抽象方法可用来禁止产生这种类的对象。

Java中的抽象类:

abstract class 在 Java 语言中表示的是一种继承关系,一个类只能使用一次继承关系。但是,一个类却可以实现多个interface。

在abstract class 中可以有自己的数据成员,也可以有非abstarct的成员方法,而在interface中,只能够有静态的不能被修改的数据成员(也就是必须是static final的,不过在 interface中一般不定义数据成员),所有的成员方法都是abstract的。

10. 普通类和抽象类有哪些区别

关键点:abstract修饰符(抽象方法)、具体实现过程、实例化、子类实现父类的抽象方法

  1. 普通类中不可含有抽象方法,可以被实例化;
  2. 抽象类,则抽象类中所有的方法自动被认为是抽象方法,没有实现过程,不可被实例化;抽象类的子类,除非也是抽象类,否则必须实现该抽象类声明的方法

11. 抽象类可以使用final修饰吗?

当然不可以,通过理解抽象类的作用我们就发现了,抽象类必须要被继承,如果用final修饰抽象类,这个抽象类就无法被继承,自然就无法使用了。

12. java中abstract类和interface的区别

相同点

A. 两者都是抽象类,都不能实例化。
B. interface实现类及abstrct class的子类都必须要实现已经声明的抽象方法。

不同点

A. interface需要实现,要用implements,而abstract class需要继承,要用extends。
B. 一个类可以实现多个interface,但一个类只能继承一个abstract class。
C. interface强调特定功能的实现,而abstractclass强调所属关系。
D. 尽管interface实现类及abstrct class的子类都必须要实现相应的抽象方法,但实现的形式不同。interface中的每一个方法都是抽象方法,都只是声明的(declaration,没有方法体),实现类必须要实现。而abstract class的子类可以有选择地实现。

13. Java中的IO流

指的是将不同的输入输出源通过流的形式进行输入或输出的操作,流是一种抽象的描述,在程序中指的是数据的一种转移方式。

IO流的分类:

(1)按照数据的流向:
输入流、输出流
(2)按照流数据的格式:
字符流、字节流
(3)按照流数据的包装过程:
节点流(低级流)、处理流(高级流)

最基本的几种进行简单介绍:

•InputStream/Reader: 所有的输入流的基类,前者是字节输入流,后者是字符输入流。

•OutputStream/Writer: 所有输出流的基类,前者是字节输出流,后者是字符输出流。

14. BIO,NIO,AIO 有什么区别?

  • BIO (Blocking I/O): 同步阻塞I/O模式,数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高(小于单机1000)的情况下,这种模型是比较不错的,可以让每一个连接专注于自己的 I/O并且编程模型简单,也不用过多考虑系统的过载、限流等问题。线程池本身就是一个天然的漏斗,可以缓冲一些系统处理不了的连接或请求。但是,当面对十万甚至百万级连接的时候,传统的 BIO 模型是无能为力的。因此,我们需要一种更高效的 I/O 处理模型来应对更高的并发量。
  • NIO (New I/O): NIO是一种同步非阻塞的I/O模型,在Java 1.4 中引入了NIO框架,对应 java.nio 包,提供了 Channel , Selector,Buffer等抽象。NIO中的N可以理解为Non-blocking,不单纯是New。它支持面向缓冲的,基于通道的I/O操作方法。 NIO提供了与传统BIO模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和 ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样,比较简单,但是性能和可靠性都不好;非阻塞模式正好与之相反。对于低负载、低并发的应用程序,可以使用同步阻塞I/O来提升开发速率和更好的维护性;对于高负载、高并发的(网络)应用,应使用 NIO 的非阻塞模式来开发。
  • AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的,也就是应用操作之后会直接返回,不会堵塞在那里,当后台处理完成,操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写,虽然 NIO 在网络操作中,提供了非阻塞的方法,但是 NIO 的 IO 行为还是同步的。对于 NIO 来说,我们的业务线程是在 IO 操作准备好时,得到通知,接着就由这个线程自行进行 IO 操作,IO操作本身是同步的。查阅网上相关资料,我发现就目前来说 AIO 的应用还不是很广泛,Netty 之前也尝试使用过 AIO,不过又放弃了。

15. Files的常用方法有哪些?

  • Files.exists() 检测文件路径是否存在
  • Files.createFile()创建文件
  • Files.createDirectory()创建文件夹
  • Files.delete() 删除文件或者目录
  • Files.copy() 复制文件
  • Files.move() 移动文件
  • Files.size()查看文件个数
  • Files.read() 读取文件
  • Files.write()写入文件

容器

1. Java中常见的容器有哪些?

常用容器可分为Collection和Map,Collection是存储对象的集合,而Map是存储键值对的集合。
其中,Collection又分为List、Set、Queue,而Map的实现类为HashMap、LinkedHashMap、TreeMap、HashTable。

List接口(有序,可重复):
  • ArrayList:底层是动态数组,支持随机访问。
  • LinkedList:底层是双向链表,只能顺序访问。
Set接口(不可重复):
  • HashSet(无序):基于哈希表。支持快速查找,但不支持有序性操作,且不维持插入顺序信息。
  • TreeSet(有序):底层是红黑树。支持快速查找(O(logn))但效率比HashSet(O(1))低。支持有序性操作,例如在一定范围内查找元素。
  • LinkedHashSet(有序):底层是链表+哈希表。使用哈希表存储元素,再维护一个双向链表保存元素的插入信息。
Queue接口:
  • LinkedList:可实现双向队列
  • PriorityQueue:基于堆结构的优先队列。
Map接口:
  • HashMap:基于哈希表。
  • LinkedHashMap:使用双向链表维护插入顺序。
  • HashTable:线程安全的HashMap,已淘汰。推荐ConcurrentHashMap。
  • TreeMap:基于红黑树。

GET 和 POST请求区别是什么?

  • GET在浏览器回退时是无害的,而POST会再次提交请求。
  • GET产生的URL地址可以被Bookmark,而POST不可以。
  • GET请求会被浏览器主动cache,而POST不会,除非手动设置。
  • GET请求只能进行url编码,而POST支持多种编码方式。
  • GET请求参数会被完整保留在浏览器历史记录里,而POST中的参数不会被保留。
  • GET请求在URL中传送的参数是有长度限制的,而POST么有。
  • 对参数的数据类型,GET只接受ASCII字符,而POST没有限制。
  • GET比POST更不安全,因为参数直接暴露在URL上,所以不能用来传递敏感信息。
  • GET参数通过URL传递,POST放在Request body中。

java中覆盖和重载的区别

  • 子类继承了父类,但重写了父类的方法,因此虽然是从父类中拿到的方法但重写之后与父类方法有了区别,因此称为覆盖(即子类方法覆盖了父类方法)
  • 重载的含义,一个类中可以有多个同名不同参(参数列表不同)的方法。
区别覆盖(override)重载(overload)
实现上子类对父类方法的重写同一个类中建立多个同名方法
参数与父类同名同参与别的方法同名不同参
返回子类与父类返回类型要一致无此要求
权限子类不能覆盖父类的private方法无此要求
父类一个方法只能在子类覆盖一次重载只要参数不同,可以多次
覆盖是针对父类方法的重写同类中的方法均可重载
重写要求子类比父类抛出更少的异常无此要求

Java 浅拷贝和深拷贝

参数*args、**args 用法与区别

Linux基本命令

  • pwd 显示工作路径

  • chmod 777和754 修改文件权限

    读取权限 r = 4
    写入权限 w = 2
    执行权限 x = 1

  • ps aux | less 输入下面的ps命令,显示所有运行中的进程

  • pgrep:通过程序的名字来查询进程,默认只显示PID

  • pidof: 根据程序名称,查找其相关进程的ID号

  • top :动态实时显示cpu、内存、进程等使用情况(类似windows下的任务管理器)

  • kill -9 进程号 :强制杀死进程

  • renice NI PID:调整已经启动的进程的nice值

  • nice -n NI COMMAND:在启动时指定nice值

  • tar -zxvf archive.tar.gz 解压一个gzip格式的压缩包

  • sed ‘s/stringa1/stringa2/g’ example.txt 将example.txt文件中的 “string1” 替换成 “string2”

  • sed ‘/^$/d’ example.txt 从example.txt文件中删除所有空白行

  • *sed '/ #/d; /^$/d’ example.txt 从example.txt文件中删除所有注释和空白行

  • echo ‘esempio’ | tr ‘[:lower:]’ ‘[:upper:]’ 合并上下单元格内容

  • sed -e ‘1d’ result.txt 从文件example.txt 中排除第一行

  • sed -n ‘/stringa1/p’ 查看只包含词汇 "string1"的行

  • *sed -e 's/ $//’ example.txt 删除每一行最后的空白字符

  • sed -e ‘s/stringa1//g’ example.txt 从文档中只删除词汇 “string1” 并保留剩余全部

  • sed -n ‘1,5p;5q’ example.txt 查看从第一行到第5行内容

  • sed -n ‘5p;5q’ example.txt 查看第5行

  • sed -e 's/00/0/g’ example.txt* 用单个零替换多个零

  • cat file1 | command( sed, grep, awk, grep, etc…) > result.txt 合并一个文件的详细说明文本,并将简介写入一个新文件中

  • cat file1 | command( sed, grep, awk, grep, etc…) >> result.txt 合并一个文件的详细说明文本,并将简介写入一个已有的文件中

  • grep Aug /var/log/messages 在文件 '/var/log/messages’中查找关键词"Aug"

  • grep ^Aug /var/log/messages 在文件 '/var/log/messages’中查找以"Aug"开始的词汇

MySQL数据库设计三范式

  • 1NF:字段不可分;
  • 2NF:有主键,非主键字段依赖主键;
  • 3NF:非主键字段不能相互依赖;

解释:

  • 1NF:原子性 字段不可再分,否则就不是关系数据库;

  • 2NF:唯一性 一个表只说明一个事物;

  • 3NF:每列都与主键有直接关系,不存在传递依赖;

    基本sql语句

    1.自然连接(natural join)
    自然连接将表中具有相同名称的列自动进行匹配,自然连接不必指定任何同等连接条件也不能认为指定哪些列需要被匹配,自然连接得到的结果表中,两表中名称相同的列只出现一次。

    select * from employee natural join department;
    

    2.内连接(inner join):产生的结果是A和B的交集(相同列里面的相同值)
    内连接查询能将左表和右表中能关联起来的数据连接后返回,返回的结果就是两个表中所有相匹配的数据。

    select * from TableA as A inner join TableB B on A.PK = B.PK;
    select * from TableA as A inner join TableB B on A.PK > B.PK;
    

    img
    3.外连接(outer join)
    内连接是要显示两张表的内存,而外连接不要求如此,外连接可以依据连接表保留左表,右表或全部表的行为而分为左外连接右外连接和全连接。

    select * from TableA as A left(right/full) join TableB as B on A.PA = B.PK;
    

    Full Join:产生的结果是A和B的并集(如果没有相同的值会用null作为值)

    img
    Left Join:产生表A的完全集,而B表中匹配的则有值(没有匹配的则以null值取代)
    img
    Right Join:产生表B的完全集,而A表中匹配的则有值(没有匹配的则以null值取代)

    img
    4.交叉连接(cross join)
    又称笛卡尔连接,交叉连接返回两个集合的笛卡尔积。

    select * from TableA cross join TableB;
    
  • 左连接:

    SELECT
    song.`name`
    FROM
    song
    LEFT JOIN
    (SELECT song_id FROM list_song WHERE song_list_id  BETWEEN 24 AND 50) s
    ON
    song.id = s.song_id
    

数据库中事务的四大特性(ACID)

如果一个数据库声称支持事务的操作,那么该数据库必须要具备以下四个特性:

原子性(Atomicity)

原子性是指事务包含的所有操作要么全部成功,要么全部失败回滚,因此事务的操作如果成功就必须要完全应用到数据库,如果操作失败则不能对数据库有任何影响。

一致性(Consistency)

一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态,也就是说一个事务执行之前和执行之后都必须处于一致性状态。

拿转账来说,假设用户A和用户B两者的钱加起来一共是5000,那么不管A和B之间如何转账,转几次账,事务结束后两个用户的钱相加起来应该还得是5000,这就是事务的一致性。

隔离性(Isolation)

隔离性是当多个用户并发访问数据库时,比如操作同一张表时,数据库为每一个用户开启的事务,不能被其他事务的操作所干扰,多个并发事务之间要相互隔离。

即要达到这么一种效果:对于任意两个并发的事务T1和T2,在事务T1看来,T2要么在T1开始之前就已经结束,要么在T1结束之后才开始,这样每个事务都感觉不到有其他事务在并发地执行。

持久性(Durability)

持久性是指一个事务一旦被提交了,那么对数据库中的数据的改变就是永久性的,即便是在数据库系统遇到故障的情况下也不会丢失提交事务的操作。

例如我们在使用JDBC操作数据库时,在提交事务方法后,提示用户事务操作完成,当我们程序执行完成直到看到提示后,就可以认定事务以及正确提交,即使这时候数据库出现了问题,也必须要将我们的事务完全执行完成,否则就会造成我们看到提示事务处理完毕,但是数据库因为故障而没有执行事务的重大错误。

1,脏读

脏读是指在一个事务处理过程里读取了另一个未提交的事务中的数据。

当一个事务正在多次修改某个数据,而在这个事务中这多次的修改都还未提交,这时一个并发的事务来访问该数据,就会造成两个事务得到的数据不一致。例如:用户A向用户B转账100元,对应SQL命令如下

    update account set money=money+100 where name=’B’;  (此时A通知B)

    update account set money=money - 100 where name=’A’;

当只执行第一条SQL时,A通知B查看账户,B发现确实钱已到账(此时即发生了脏读),而之后无论第二条SQL是否执行,只要该事务不提交,则所有操作都将回滚,那么当B以后再次查看账户时就会发现钱其实并没有转。

2,不可重复读

不可重复读是指在对于数据库中的某个数据,一个事务范围内多次查询却返回了不同的数据值,这是由于在查询间隔,被另一个事务修改并提交了。

例如事务T1在读取某一数据,而事务T2立马修改了这个数据并且提交事务给数据库,事务T1再次读取该数据就得到了不同的结果,发送了不可重复读。

不可重复读和脏读的区别是,脏读是某一事务读取了另一个事务未提交的脏数据,而不可重复读则是读取了前一事务提交的数据。

在某些情况下,不可重复读并不是问题,比如我们多次查询某个数据当然以最后查询得到的结果为主。但在另一些情况下就有可能发生问题,例如对于同一个数据A和B依次查询就可能不同,A和B就可能打起来了……

3,虚读(幻读)

幻读是事务非独立执行时发生的一种现象。例如事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作,这时事务T2又对这个表中插入了一行数据项,而这个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果再查看刚刚修改的数据,会发现还有一行没有修改,其实这行是从事务T2中添加的,就好像产生幻觉一样,这就是发生了幻读。

幻读和不可重复读都是读取了另一条已经提交的事务(这点就脏读不同),所不同的是不可重复读查询的都是同一个数据项,而幻读针对的是一批数据整体(比如数据的个数)。

现在来看看MySQL数据库为我们提供的四种隔离级别:
  1. **Serializable (串行化):**可避免脏读、不可重复读、幻读的发生。
  2. **Repeatable read (可重复读):**可避免脏读、不可重复读的发生。
  3. **Read committed (读已提交):**可避免脏读的发生。
  4. **Read uncommitted (读未提交):**最低级别,任何情况都无法保证。

以上四种隔离级别最高的是Serializable级别,最低的是Read uncommitted级别,当然级别越高,执行效率就越低。像Serializable这样的级别,就是以锁表的方式(类似于Java多线程中的锁)使得其他的线程只能在锁外等待,所以平时选用何种隔离级别应该根据实际情况。在MySQL数据库中默认的隔离级别为Repeatable read (可重复读)。

在MySQL数据库中,支持上面四种隔离级别,默认的为Repeatable read (可重复读);而在Oracle数据库中,只支持Serializable (串行化)级别和Read committed (读已提交)这两种级别,其中默认的为Read committed级别。

Redis是什么

Redis是现在最受欢迎的NoSQL数据库之一,Redis是一个使用ANSI C编写的开源、包含多种数据结构、支持网络、基于内存、可选持久性的键值对存储数据库,其具备如下特性:

  • 基于内存运行,性能高效
  • 支持分布式,理论上可以无限扩展
  • key-value存储系统
  • 开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API

相比于其他数据库类型,Redis具备的特点是:

  • C/S通讯模型
  • 单进程单线程模型
  • 丰富的数据类型
  • 操作具有原子性
  • 持久化
  • 高并发读写
  • 支持lua脚本
Redis的应用场景有哪些?

Redis 的应用场景包括:缓存系统(“热点”数据:高频读、低频写)计数器消息队列系统排行榜社交网络实时系统

img

Redis的数据类型及主要特性

Redis提供的数据类型主要分为5种自有类型和一种自定义类型,这5种自有类型包括:String类型哈希类型列表类型集合类型顺序集合类型

img

简单介绍Spring是什么?

1、Spring的核心是一个轻量级(Lightweight)的容器(Container)。
2、Spring是实现IoC(Inversion of Control)容器和非入侵性(No intrusive)的框架。
3、Spring提供AOP(Aspect-oriented programming)概念的实现方式。
4、Spring提供对持久层(Persistence)、事物(Transcation)的支持。
5、Spring供MVC Web框架的实现,并对一些常用的企业服务API(Application Interface)提供一致的模型封装。
6、Spring提供了对现存的各种框架(Structs、JSF、Hibernate、Ibatis、Webwork等)相整合的方案。
总之,Spring是一个全方位的应用程序框架。

Spring MVC

MVC框架

M: Model模型:和数据库进行交互

V: View,视图: 产生html页面

C: Controller,控制器: 接收请求,进行处理,与M和V进行交互,返回应答

MVC 是 Model、View 和 Controller 的缩写,分别代表 Web 应用程序中的 3 种职责。

  • 模型:用于存储数据以及处理用户请求的业务逻辑。
  • 视图:向控制器提交数据,显示模型中的数据。
  • 控制器:根据视图提出的请求判断将请求和数据交给哪个模型处理,将处理后的有关结果交给哪个视图更新显示。

基于 Servlet 的 MVC 模式的具体实现如下。

  • 模型:一个或多个 JavaBean 对象,用于存储数据(实体模型,由 JavaBean 类创建)和处理业务逻辑(业务模型,由一般的 Java 类创建)。
  • 视图:一个或多个 JSP 页面,向控制器提交数据和为模型提供数据显示,JSP 页面主要使用 HTML 标记和 JavaBean 标记来显示数据。
  • 控制器:一个或多个 Servlet 对象,根据视图提交的请求进行控制,即将请求转发给处理业务逻辑的 JavaBean,并将处理结果存放到实体模型

Spring Bean的作用域和生命周期

一、Bean的作用域

在Bean容器启动会读取bean的xml配置文件,然后将xml中每个bean元素分别转换成BeanDefinition对象。在BeanDefinition对象中有scope 属性,就是它控制着bean的作用域。
Spring框架支持5种作用域,有三种作用域是当开发者使用基于web的ApplicationContext的时候才生效的。下面就是Spring直接支持的作用域了,当然开发者也可以自己定制作用域。

作用域描述
单例(singleton)(默认)每一个Spring IoC容器都拥有唯一的一个实例对象
原型(prototype)一个Bean定义,任意多个对象
请求(request)一个HTTP请求会产生一个Bean对象,也就是说,每一个HTTP请求都有自己的Bean实例。只在基于web的Spring ApplicationContext中可用
会话(session)限定一个Bean的作用域为HTTPsession的生命周期。同样,只有基于web的Spring ApplicationContext才能使用
全局会话(global session)限定一个Bean的作用域为全局HTTPSession的生命周期。通常用于门户网站场景,同样,只有基于web的Spring ApplicationContext可用

二、Bean的生命周期

前面章节介绍了bean容器以及bean的配置与注入,本章节学习bean的生命周期,了解bean是怎么来的又是怎么没的。

img

ApplicationContext容器中,Bean的生命周期流程如上图所示,流程大致如下:

  1. 首先容器启动后,会对scope为singleton且非懒加载的bean进行实例化,
  2. 按照Bean定义信息配置信息,注入所有的属性,
  3. 如果Bean实现了BeanNameAware接口,会回调该接口的setBeanName()方法,传入该Bean的id,此时该Bean就获得了自己在配置文件中的id,
  4. 如果Bean实现了BeanFactoryAware接口,会回调该接口的setBeanFactory()方法,传入该Bean的BeanFactory,这样该Bean就获得了自己所在的BeanFactory,
  5. 如果Bean实现了ApplicationContextAware接口,会回调该接口的setApplicationContext()方法,传入该Bean的ApplicationContext,这样该Bean就获得了自己所在的ApplicationContext,
  6. 如果有Bean实现了BeanPostProcessor接口,则会回调该接口的postProcessBeforeInitialzation()方法,
  7. 如果Bean实现了InitializingBean接口,则会回调该接口的afterPropertiesSet()方法,
  8. 如果Bean配置了init-method方法,则会执行init-method配置的方法,
  9. 如果有Bean实现了BeanPostProcessor接口,则会回调该接口的postProcessAfterInitialization()方法,
  10. 经过流程9之后,就可以正式使用该Bean了,对于scope为singleton的Bean,Spring的ioc容器中会缓存一份该bean的实例,而对于scope为prototype的Bean,每次被调用都会new一个新的对象,期生命周期就交给调用方管理了,不再是Spring容器进行管理了
  11. 容器关闭后,如果Bean实现了DisposableBean接口,则会回调该接口的destroy()方法,
  12. 如果Bean配置了destroy-method方法,则会执行destroy-method配置的方法,至此,整个Bean的生命周期结束。

这里在UserBean类基础上进行改造,增加了name属性并实现了ApplicationContextAware接口。

Springboot 注解

@PathVariable :

  • 通过 @PathVariable 可以将 URL 中占位符参数绑定到控制器处理方法的入参中:URL 中的 {xxx} 占位符可以通过@PathVariable(“xxx“) 绑定到操作方法的入参中。

@RequestBody和@RequestParam

  • 两个注解都是用于方法中接收参数使用的,两者也有一定的区别。
  • @RequestBody这个一般处理的是在ajax请求中声明contentType: “application/json; charset=utf-8”时候。也就是json数据或者xml(我没用过这个,用的是json)
  • @RequestParam这个一般就是在ajax里面没有声明contentType的时候,为默认的。。。urlencode格式时,用这个。
  • @RequestBody可以直接将页面中的参数封装成实体类中的数据传输给后端

@PostMapping @GetMapping @RequestMapping

  • @GetMapping是一个组合注解,是@RequestMapping(method = RequestMethod.GET)的缩写。
  • @PostMapping是一个组合注解,是@RequestMapping(method = RequestMethod.POST)的缩写。
  • @RequestMapping是一个非 组合注解,需要自定义请求方式。

@RestController和@Controller

  • RestController相当于Controller+ResponseBody注解
    如果只是使用@RestController注解Controller,则Controller中的方法无法返回jsp页面,或者html,配置的视图解析器 ,也就是相当于在方法上面自动加了ResponseBody注解,所以没办法跳转并传输数据到另一个页面,所以InternalResourceViewResolver也不起作用,返回的内容就是Return 里的内容,即数据直接甩在当前请求的页面上,适用于ajax异步请求。

Springboot各个层之间的联系

Springboot框架分controller层,service层和dao层,分别负责不同的业务。

  • Controller层沟通前后端,注解为@RestController
  • Service层沟通DAO层和Ccontroller层,注解为@Service
  • DAO层沟通数据库和service层,注解为@Repository

View层👉Controller层(响应用户请求)👉Service层(接口👉接口实现类)👉DAO层,即Mapper层(抽象类:xxxMapper.java文件,具体实现在xxxMapper.xml)👉Model层(实体类:xxx.java)

img

  1. entity层/model层/pojo层/domain层:
    • 存放的是实体类,属性值与数据库中的属性值保持一致。 实现set和get方法。
    • 一般数据库一张表对应一个实体类,类属性同表字段一一对应。
  2. dao层:mapper层
    • 对数据库进行持久化操作,他的方法是针对数据库操作的,基本用到的就是增删改查。它只是个接口只有方法名字,具体实现在mapper.xml中
    • dao层的作用为访问数据库,向数据库发送sql语句,完成数据的增删改查任务。
  3. **service层:**业务层,
    • service层即业务逻辑层。
    • service层的作用为完成功能设计。
    • service层调用dao层接口,接收dao层返回的数据,完成项目的基本功能设计。
  4. **controller层:**控制器层,
    • 导入service层,调用service方法,controller通过接收前端传过来的参数进行业务操作,在返回一个指定的路径或者数据表。表单等交互动作的处理,调到Service,将Service层的数据对象返回到视图层
    • controller层即控制层。
    • controller层的功能为请求和响应控制。
    • controller层负责前后端交互,接受前端请求,调用service层,接收service层返回的数据,最后返回具体的页面和数据到客户端。

int与integer的区别

1.Integer是int提供的封装类,而int是java的基本数据类型

2.Integer默认值是null,而int默认值是0;

3.声明为Integer的变量需要实例化,而声明为int的变量不需要实例化

4.Integer是对象,用一个引用指向这个对象,而int是基本类型,直接存储数据

类似的还有:float Float;double Double;string String等

举个例子:当需要往ArrayList,HashMap中放东西时,像int,double这种内建类型是放不进去的,因为容器都是装 object的,这是就需要这些内建类型的外覆类了。

Java中每种内建类型都有相应的外覆类

Array 和ArrayList的区别

  1. 长度的区别:

    • Array是数组,声明好之后,其长度就已经固定。

      ArrayList底层是用数组实现的,但是ArrayList的长度是可变的,在每次添加时,如果发现空间不足的话,会创建一个长度大概是原来1.5倍的新数组(java8源码),然后把原来的数组元素复制过去。

  2. 存放数据的区别:

    • Array可以除了可以存放对象类型的数据之外,还可以存放基本数据类型的数据。

      ArrayList只能存放对象数据类型的数据,因为它的类在定义时已经是针对Object的子类做了泛型的约束。

HashTable和HashMap区别

1、继承的父类不同

Hashtable继承自Dictionary类,而HashMap继承自AbstractMap类。但二者都实现了Map接口。

2、线程安全性不同

javadoc中关于hashmap的一段描述如下:此实现不是同步的。如果多个线程同时访问一个哈希映射,而其中至少一个线程从结构上修改了该映射,则它必须保持外部同步。

Hashtable 中的方法是Synchronized的,而HashMap中的方法在缺省情况下是非Synchronize的。在多线程并发的环境下,可以直接使用Hashtable,不需要自己为它的方法实现同步,但使用HashMap时就必须要自己增加同步处理。(结构上的修改是指添加或删除一个或多个映射关系的任何操作;仅改变与实例已经包含的键关联的值不是结构上的修改。)这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象,则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作,以防止对映射进行意外的非同步访问,如下所示:

3、是否提供contains方法

HashMap把Hashtable的contains方法去掉了,改成containsValue和containsKey,因为contains方法容易让人引起误解。

Hashtable则保留了contains,containsValue和containsKey三个方法,其中contains和containsValue功能相同。

4、key和value是否允许null值

其中key和value都是对象,并且不能包含重复key,但可以包含重复的value。

通过上面的ContainsKey方法和ContainsValue的源码我们可以很明显的看出:

Hashtable中,key和value都不允许出现null值。但是如果在Hashtable中有类似put(null,null)的操作,编译同样可以通过,因为key和value都是Object类型,但运行时会抛出NullPointerException异常,这是JDK的规范规定的。
HashMap中,null可以作为键,这样的键只有一个;可以有一个或多个键所对应的值为null。当get()方法返回null值时,可能是 HashMap中没有该键,也可能使该键所对应的值为null。因此,在HashMap中不能由get()方法来判断HashMap中是否存在某个键, 而应该用containsKey()方法来判断。

5、两个遍历方式的内部实现上不同

Hashtable、HashMap都使用了 Iterator。而由于历史原因,Hashtable还使用了Enumeration的方式 。

6、hash值不同

哈希值的使用不同,HashTable直接使用对象的hashCode而HashMap重新计算hash值

hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值。

Hashtable计算hash值,直接用key的hashCode(),而HashMap重新计算了key的hash值,Hashtable在求hash值对应的位置索引时,用取模运算,而HashMap在求位置索引时,则用与运算,且这里一般先用hash&0x7FFFFFFF后,再对length取模,&0x7FFFFFFF的目的是为了将负的hash值转化为正值,因为hash值有可能为负数,而&0x7FFFFFFF后,只有符号外改变,而后面的位都不变。

7、内部实现使用的数组初始化和扩容方式不同

HashTable在不指定容量的情况下的默认容量为11,而HashMap为16,Hashtable不要求底层数组的容量一定要为2的整数次幂,而HashMap则要求一定为2的整数次幂。
Hashtable扩容时,将容量变为原来的2倍加1,而HashMap扩容时,将容量变为原来的2倍。

Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11,增加的方式是 old*2+1。

session和cookie的区别,这个技术是解决什么问题

  1. cookie数据存放在客户的浏览器上,session数据放在服务器上。
  2. cookie不是很安全,别人可以分析存放在本地的COOKIE并进行COOKIE欺骗
    考虑到安全应当使用session。
  3. session会在一定时间内保存在服务器上。当访问增多,会比较占用你服务器的性能
    考虑到减轻服务器性能方面,应当使用COOKIE。
  4. 单个cookie保存的数据不能超过4K,很多浏览器都限制一个站点最多保存20个cookie。
  5. Session是在服务端保存的一个数据结构,用来跟踪用户的状态,这个数据可以保存在集群、数据库、文件中;
    Cookie是客户端保存用户信息的一种机制,用来记录用户的一些信息,也是实现Session的一种方式。

TCP和UDP

TCP三次握手过程

太厉害了,终于有人能把TCP/IP 协议讲的明明白白了

**第一次握手:**主机A通过向主机B 发送一个含有同步序列号的标志位的数据段给主机B,向主机B 请求建立连接,通过这个数据段, 主机A告诉主机B 两件事:我想要和你通信;你可以用哪个序列号作为起始数据段来回应我。

**第二次握手:**主机B 收到主机A的请求后,用一个带有确认应答(ACK)和同步序列号(SYN)标志位的数据段响应主机A,也告诉主机A两件事:我已经收到你的请求了,你可以传输数据了;你要用那个序列号作为起始数据段来回应我

**第三次握手:**主机A收到这个数据段后,再发送一个确认应答,确认已收到主机B 的数据段:"我已收到回复,我现在要开始传输实际数据了,这样3次握手就完成了,主机A和主机B 就可以传输数据了。

3次握手的特点

没有应用层的数据 ,SYN这个标志位只有在TCP建立连接时才会被置1 ,握手完成后SYN标志位被置0。

TCP建立连接要进行3次握手,而断开连接要进行4次

太厉害了,终于有人能把TCP/IP 协议讲的明明白白了

第一次: 当主机A完成数据传输后,将控制位FIN置1,提出停止TCP连接的请求 ;

第二次: 主机B收到FIN后对其作出响应,确认这一方向上的TCP连接将关闭,将ACK置1;

第三次: 由B 端再提出反方向的关闭请求,将FIN置1 ;

第四次: 主机A对主机B的请求进行确认,将ACK置1,双方向的关闭结束.。

由TCP的三次握手和四次断开可以看出,TCP使用面向连接的通信方式, 大大提高了数据通信的可靠性,使发送数据端和接收端在数据正式传输前就有了交互, 为数据正式传输打下了可靠的基础。

名词解释

1、ACK 是TCP报头的控制位之一,对数据进行确认。确认由目的端发出, 用它来告诉发送端这个序列号之前的数据段都收到了。 比如确认号为X,则表示前X-1个数据段都收到了,只有当ACK=1时,确认号才有效,当ACK=0时,确认号无效,这时会要求重传数据,保证数据的完整性。

2、SYN 同步序列号,TCP建立连接时将这个位置1。

3、FIN 发送端完成发送任务位,当TCP完成数据传输需要断开时,,提出断开连接的一方将这位置1。

TCP与UDP区别总结:

  1. TCP面向连接(如打电话要先拨号建立连接);UDP是无连接的,即发送数据之前不需要建立连接
  2. TCP提供可靠的服务。也就是说,通过TCP连接传送的数据,无差错,不丢失,不重复,且按序到达;UDP尽最大努力交付,即不保 证可靠交付
  3. TCP面向字节流,实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的
    UDP没有拥塞控制,因此网络出现拥塞不会使源主机的发送速率降低(对实时应用很有用,如IP电话,实时视频会议等)
  4. 每一条TCP连接只能是点到点的;UDP支持一对一,一对多,多对一和多对多的交互通信
  5. TCP首部开销20字节;UDP的首部开销小,只有8个字节
  6. TCP的逻辑通信信道是全双工的可靠信道,UDP则是不可靠信道

TCP/IP

  1. 物理层:
  • 作用:定义一些电器,机械,过程和规范,如集线器;
  • PDU(协议数据单元):bit/比特
  • 设备:集线器HUB;
  • 注意:没有寻址的概念;
  1. 数据链路层:
  • 作用:定义如何格式化数据,支持错误检测;
  • 典型协议:以太网,帧中继(古董级VPN)
  • PDU:frame(帧)设备:以太网交换机;
  • 备注:交换机通过MAC地址转发数据,逻辑链路控制;
  1. 网络层:
  • 作用:定义一个逻辑的寻址,选择最佳路径传输,路由数据包;
  • 典型协议:IP,IPX,ICMP,ARP(IP->MAC),IARP;
  • PDU:packet/数据包;
  • 设备:路由器
  • 备注:实现寻址
  1. 传输层:
  • 作用:提供可靠和尽力而为的传输;
  • 典型协议:TCP,UDP,SPX,port(65535个端口),EIGRP,OSPF,
  • PDU:fragment 段;
  • 无典型设备;
  • 备注:负责网络传输和会话建立;
  1. 会话层:
  • 作用:控制会话,建立管理终止应用程序会话;
  • 典型协议:NFS, SQL, ASP, PHP, JSP, RSVP(资源源预留协议), windows,
  • 备注:负责会话建立;
  1. 表示层:
  • 作用:格式化数据;
  • 典型协议:ASCII, JPEG. PNG, MP3. WAV, AVI,
  • 备注:可以提供加密服务;
  1. 应用层:
  • 作用:控制应用程序;
  • 典型协议:telnet, ssh, http, ftp, smtp, rip, BGP, (未完待续)
  • 备注:为应用程序提供网络服务;

Q:什么时候有PDU?

A:当需要跟别人通信时候才有。

Java的垃圾回收机制

垃圾收集GC(Garbage Collection)是Java语言的核心技术之一, 在Java中,程序员不需要去关心内存动态分配和垃圾回收的问题,这一切都交给了JVM来处理。

1. 什么样的对象才是垃圾?

这个问题其实很简单,对于Java对象来讲,如果说这个对象没有被其他对象所引用该对象就是无用的,此对象就被称为垃圾,其占用的内存也就要被销毁。那么自然而然的就引出了我们的第二个问题,判断对象为垃圾的算法都有哪些?

2. 标记垃圾的算法

Java中标记垃圾的算法主要有两种, 引用计数法可达性分析算法

引用计数法

引用计数法就是给对象中添加一个引用计数器,每当有一个地方引用它,计数器就加 1;当引用失效,计数器就减 1;任何时候计数器为 0 的对象就是不可能再被使用的,可以当做垃圾收集。这种方法实现起来很简单而且优缺点都很明显。

  • 优点 执行效率高,程序执行受影响较小
  • 缺点 无法检测出循环引用的情况,导致内存泄露
可达性分析算法

这个算法的基本思想就是通过一系列的称为 “GC Roots” 的对象作为起点,从这些节点开始向下搜索,节点所走过的路径称为引用链,当一个对象到 GC Roots 没有任何引用链相连的话,则证明此对象是不可用的。

那么什么对象可以作为GCRoot?

  • 虚拟机栈中的引用对象
  • 方法区中的常量引用对象
  • 方法区中的类静态属性引用对象
  • 本地方法栈中的引用对象
  • 活跃线程中的引用对象
3. 如何将垃圾回收?

在Java中存在着四种垃圾回收算法,标记清除算法复制算法标记整理算法以及分代回收算法。我们接下来会分别介绍他们。

标记清除算法

该算法分为“标记”和“清除”两个阶段:标记阶段的任务是标记出所有需要被回收的对象,清除阶段就是回收被标记的对象所占用的空间。它是最基础的收集算法,效率也很高,但是会带来两个明显的问题:

  • 效率问题
  • 空间问题(标记清除后会产生大量不连续的碎片)
复制算法

为了解决效率问题,我们开发出了复制算法。它可以将内存分为大小相同的两块,每次 使用其中的一块。当第一块的内存使用完后,就将还存活的对象复制到另一块去,然后再把使用的空间一次清理掉。这样就使每次的内存回收都是对内存区间的一半进行回收。

简单来说就是该对象分为对象面以及空闲面,对象在对象面上创建,对象面上存活的对象会被复制到空闲面,接下来就可以清除对象面的内存。

这种算法的优缺点也比较明显

  • 优点:解决碎片化问题,顺序分配内存简单高效
  • 缺点:只适用于存活率低的场景,如果极端情况下如果对象面上的对象全部存活,就要浪费一半的存储空间。
标记整理算法

为了解决复制算法的缺陷,充分利用内存空间,提出了标记整理算法。该算法标记阶段和标记清除一样,但是在完成标记之后,它不是直接清理可回收对象,而是将存活对象都向一端移动,然后清理掉端边界以外的内存。

分代收集算法

当前虚拟机的垃圾收集都采用分代收集算法,这种算法就是根据具体的情况选择具体的垃圾回收算法。一般将 java 堆分为新生代和老年代,这样我们就可以根据各个年代的特点选择合适的垃圾收集算法。

比如在新生代中,每次收集都会有大量对象死去,所以可以选择复制算法,只需要付出少量对象的复制成本就可以完成每次垃圾收集。而老年代的对象存活几率是比较高的,而且没有额外的空间对它进行分配担保,所以我们必须选择“标记-清除”或“标记-整理”算法进行垃圾收集。

Java文本文件读取的大致过程如下:

  1. 构建文件对象,

  2. 使用文件对象构造Reader对象可以是FileReaderInputStreamReaderRandomAccessFile

  3. 使用Reader对像构建BufferedReader对象(主要使用其**readLine()**方法,用于按行读取文件)

  4. 按行读取文件,将每行获取到的字符串进行处理。

索引的优点和缺点

一、为什么要创建索引呢(优点)?
这是因为,创建索引可以大大提高系统的性能。
第一, 通过创建唯一性索引,可以保证数据库表中每一行数据的唯一性。
第二, 可以大大加快数据的检索速度,这也是创建索引的最主要的原因。
第三, 可以加速表和表之间的连接,特别是在实现数据的参考完整性方面特别有意义。
第四, 在使用分组和排序子句进行数据检索时,同样可以显著减少查询中分组和排序的时间。
第五, 通过使用索引,可以在查询的过程中,使用优化隐藏器,提高系统的性能。

二、建立方向索引的不利因素(缺点)
也许会有人要问:增加索引有如此多的优点,为什么不对表中的每一个列创建一个索引呢?这种想法固然有其合理性,然而也有其片面性。虽然,索引有许多优点,但是,为表中的每一个列都增加索引,是非常不明智的。这是因为,增加索引也有许多不利的一个方面。

第一, 创建索引和维护索引要耗费时间,这种时间随着数据量的增加而增加。
第二, 索引需要占物理空间,除了数据表占数据空间之外,每一个索引还要占一定的物理空间,如果要建立聚簇索引,那么需要的空间就会更大。
第三, 当对表中的数据进行增加、删除和修改的时候,索引也要动态的维护,这样就降低了数据的维护速度。

使用线程

有三种使用线程的方法:
  • 实现 Runnable 接口;
  • 实现 Callable 接口;
  • 继承 Thread 类。

实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务,不是真正意义上的线程,因此最后还需要通过 Thread 来调用。可以理解为任务是通过线程驱动从而执行的。

start()和run()的区别:
  • start方法:

    通过该方法启动线程的同时也创建了一个线程,真正实现了多线程。无需等待run()方法中的代码执行完毕,就可以接着执行下面的代码。此时start()的这个线程处于就绪状态,当得到CPU的时间片后就会执行其中的run()方法。这个run()方法包含了要执行的这个线程的内容,run()方法运行结束,此线程也就终止了。

  • run方法:

    通过run方法启动线程其实就是调用一个类中的方法,当作普通的方法的方式调用。并没有创建一个线程,程序中依旧只有一个主线程,必须等到run()方法里面的代码执行完毕,才会继续执行下面的代码,这样就没有达到写线程的目的。
    而run方法是业务逻辑实现的地方,本质上和任意一个类的任意一个成员方法并没有任何区别,可以重复执行,被一个线程反复调用,也可以被单独调用

总结一下:
1.start() 可以启动一个新线程,run()不能
2.start()不能被重复调用,run()可以
3.start()中的run代码可以不执行完就继续执行下面的代码,即进行了线程切换。直接调用run方法必须等待其代码全部执行完才能继续执行下面的代码。
4.start() 实现了多线程,run()没有实现多线程。

设计模式

一、前言

设计模式是解决问题的方案,学习现有的设计模式可以做到经验复用。拥有设计模式词汇,在沟通时就能用更少的词汇来讨论,并且不需要了解底层细节。

二、创建型

  • 单例(Singleton)

    确保一个类只有一个实例,并提供该实例的全局访问点。

  • 简单工厂(Simple Factory)

    在创建一个对象时不向客户暴露内部细节,并提供一个创建对象的通用接口。

  • 工厂方法(Factory Method)

    定义了一个创建对象的接口,但由子类决定要实例化哪个类。工厂方法把实例化操作推迟到子类。

  • 抽象工厂(Abstract Factory)

    提供一个接口,用于创建 相关的对象家族

  • 生成器(Builder)

    封装一个对象的构造过程,并允许按步骤构造。

  • 原型模式(Prototype)

    使用原型实例指定要创建对象的类型,通过复制这个原型来创建新对象。

三、行为型

  • 责任链(Chain Of Responsibility)

    使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链发送该请求,直到有一个对象处理它为止。

  • 命令(Command)

    将命令封装成对象中,具有以下作用:

    • 使用命令来参数化其它对象
    • 将命令放入队列中进行排队
    • 将命令的操作记录到日志中
    • 支持可撤销的操作
  • 解释器(Interpreter)

    为语言创建解释器,通常由语言的语法和语法分析来定义。

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值