首页

源码搜藏网

首页 > 安卓源码 > 技术博客 >

Java中那些常见概念总结

创建时间：2019-05-27 23:59  浏览 次

1.HashMap和HashTable的区别

2.java的线程安全类

Vector、Stack、HashTable、ConcurrentHashMap、Properties

3.java集合框架

Collection - List

Collection - List - ArrayList

Collection - List - LinkedList

Collection - List - Vector

Collection - List - Vector - Stack

Collection - Set

Collection - Set - HashSet

Collection - Set - TreeSet

Collection - Set - LinkedHashSet

Map

Map - HashMap

Map - TreeMap

Map - HashTable

Map - WeakHashMap

Map - LinkedHashMap

SparseArray

ArrayMap

在除需要排序时使用TreeSet,TreeMap外,都应使用HashSet,HashMap,因为他们的效率更高。

3.1 ArrayList的构造函数有三个

3.2 Iterator(迭代器)支持从源集合安全地删除对象,防止并发修改异常(ConcurrentModifiedException)

4.Java垃圾回收机制

4.1 调用system.gc() Runtime.getRuntime.gc()

4.2 垃圾回收:释放那些不再持有任何引用的对象的内存

4.3 怎样判断是否需要收集：

4.4 垃圾回收方法

4.5 内存分配

其他

5.一些重要的关键字

6.多线程 & 并发 & 同步 & 锁

6.1 线程的run方法和start方法

6.2 ReadWriteLock(读写锁)

写写互斥 读写互斥 读读并发
在读多写少的情况下可以提高效率

6.3 resume(继续挂起的线程)和suspend(挂起线程)一起用

6.4 wait与notify、notifyall一起用

6.5 sleep与wait的异同点

6.6 让一个线程停止执行

异常 - 停止执行
休眠 - 停止执行
阻塞 - 停止执行

6.7 ThreadLocal相关

ThreadLocal解决了变量并发访问的冲突问题

与synchronized同步机制的比较

7.接口与抽象类

8.Statement接口

8.1

8.2 Statement与PrepareStatement的区别

Statement statement = conn.createStatement();
PreparedStatement preStatement = conn.prepareStatement(sql);
ResultSet rSet = statement.executeQuery(sql);
ResultSet pSet = preStatement.executeQuery();

由上可以看出，PreparedStatement有预编译的过程，已经绑定sql，之后无论执行多少遍，都不会再去进行编译，而 statement 不同，如果执行多遍，则相应的就要编译多少遍sql，所以从这点看，preStatement 的效率会比 Statement要高一些

preStatement是预编译的，所以可以有效的防止SQL注入等问题

PreparedStatement更胜一筹

9.抽象类和最终类

抽象类可以没有抽象方法,最终类可以,没有最终方法

最终类不能被继承,最终方法不能被重写(可以重载)

10.异常

10.1 throw、throws、try...catch、finally

10.2 关于finally

10.3 受检查异常和运行时异常

Java中那些常见概念总结

11.this & super

11.1 super出现在父类的子类中。有三种存在方式

11.2 this() & super()在构造方法中的区别

12.修饰符一览

修饰符 类内部     同一个包        子类      任何地方
private         yes
default         yes         yes
protected       yes         yes yes
public          yes         yes yes         yes

13.构造内部类对象

public class Enclosingone {
    public class Insideone {}
    public static class Insideone{}
}

public class Test {
    public static void main(String[] args) {
    Enclosingone.Insideone obj1 = new Enclosingone().new Insideone();
    Enclosingone.Insideone obj2 = new Enclosingone.Insideone();
    }
}

14.序列化

声明为static和transient类型的数据不能被序列化,序列化的笔记参见Java-note-序列化.md

15.Java的方法区

与堆一样,是线程共享的区域。方法区中存储：被虚拟机加载的类信息，常量，静态变量，编译器编译后的代码等数据。这个区域的内存回收目标主要是针对常量池的对象的回收和对类型的卸载。

16.正则表达式

次数符号

* 0或多次
+ 1或多次
？0或1次
{n} 恰n次
{n,m} 从n到m次

其他符号

符号 等价形式

\d      [0-9]
\D      [^0-9]  
\w      [a-zA-Z_0-9]
\W      [^a-zA-Z_0-9]
\s      [\t\n\r\f]
\S      [^\t\n\r\f]
.       任何字符

边界匹配器

行开头 ^
行结尾 $
单词边界 b

贪婪模式:最大长度匹配 非贪婪模式:匹配到结果就好,最短匹配

环视

字符  描述      匹配对象
.       单个任意字符          
[...]   字符组         列出的任意字符
[^...]  未列出的任意字符
^       caret       行的起始位置
$       dollar      行的结束位置
\<      单词的起始位置
\>      单词的结束位置
\b      单词边界
\B      非单词边界
(?=Expression)      顺序肯定环视          成功,如果右边能够匹配
(?!Expression)      顺序否定环视          成功,如果右边不能够匹配
(?<=Expression)     逆序肯定环视          成功,如果左边能够匹配
(?<!Expression)     逆序否定环视          成功,如果左边不能够匹配

举例:北京市(海定区)(朝阳区)(西城区)

Regex: .*(?=()

模式和匹配器的典型调用次序

  1. b = m.matches();

17.Servlet & JSP & Tomcat

17.1 Servlet继承实现结构

Servlet (接口)-->      init|service|destroy方法
GenericServlet(抽象类)  -->      与协议无关的Servlet
HttpServlet(抽象类)        -->      实现了http协议
自定义Servlet          -->      重写doGet/doPost

17.2 编写Servlet的步骤

17.3 Servlet生命周期

17.4 过程

17.5 doPost方法要抛出的异常:ServletExcception、IOException

17.6 Servlet容器装载Servlet

17.7 HttpServlet容器响应web客户请求流程

17.8 HttpServletRequest完成的功能

17.9 HttpServletResponse完成的功能

17.10 session

HttpSession session = request.getSession(boolean create)
返回当前请求的会话

17.11 JSP的前身就是Servlet

17.12 Tomcat容器的等级

Tomcat - Container - Engine - Host - Servlet - 多个Context(一个Context对应一个web工程)-Wrapper

17.13 Servlet与JSP九大内置对象的关系

JSP对象 怎样获得

1. out  ->      response.getWriter
2. request      ->      Service方法中的req参数
3. response         ->      Service方法中的resp参数
4. session      ->      request.getSession
5. application  ->      getServletContext
6. exception        ->      Throwable
7. page ->      this
8. pageContext      ->      PageContext
9. Config           ->      getServletConfig

exception是JSP九大内置对象之一，其实例代表其他页面的异常和错误。只有当页面是错误处理页面时，即isErroePage为 true时，该对象才可以使用。

18.struts

19.Hibernate的7大鼓励措施

20.JVM

20.1 JVM内存配置参数

20.2 JVM内存结构

21.面向对象的五大基本原则(solid)

面向对象设计原则

说明：将方法调用保持在界限内，只调用属于以下范围的方法：
该对象本身（本地方法）对象的组件 被当作方法参数传进来的对象 此方法创建或实例化的任何对象

22.null可以被强制转型为任意类型的对象。

23.代码执行次序

b.初始化子类中的静态成员变量和静态代码块
c.初始化父类的普通成员变量和构造代码块(按次序)，再执行父类的构造方法(注意父类构造方法中的子类方法覆盖)
d.初始化子类的普通成员变量和构造代码块(按次序)，再执行子类的构造方法

24.红黑树

二叉搜索树:(Binary Search Tree又名：二叉查找树,二叉排序树)它或者是一棵空树,或者是具有下列性质的二叉树： 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。

红黑树的定义:满足以下五个性质的二叉搜索树

黑高

从某个结点x出发(不含x)到达一个叶结点的任意一条简单路径上的黑色结点个数称为该结点的黑高。
红黑树的黑高为其根结点的黑高。

其他

25.排序

复杂度：O(n^2) - O(n) - O(n^2) - O(1)[平均 - 最好 - 最坏 - 空间复杂度]

复杂度：O(nlogn) - O(nlgn) - O(nlgn) - O(n)[平均 - 最好 - 最坏 - 空间复杂度]

不支持相同元素,没有稳定性问题
复杂度：平均最差O(nlogn)

栈空间0(lgn) - O(n)

26.查找与散列

26.1 散列函数设计

简单、均匀,不易产生冲突。但需事先知道关键字的分布情况,适合查找表较小且连续的情况,故现实中并不常用

平方取中法 折叠法 更多....

26.2 冲突处理

闭散列(开放地址方法):要求装填因子a较小，闭散列方法把所有记录直接存储在散列表中

开散列(链地址法):原地处理

27.枚举类

JDK1.5出现 每个枚举值都需要调用一次构造函数

28.数组复制方法

29.多态

30.Java文件

.java文件可以包含多个类，唯一的限制就是：一个文件中只能有一个public类， 并且此public类必须与
文件名相同。而且这些类和写在多个文件中没有区别。

31.Java移位运算符

java中有三种移位运算符

1.<< :左移运算符,x << 1,相当于x乘以2(不溢出的情况下),低位补0

2.带符号右移,x >> 1,相当于x除以2,正数高位补0,负数高位补1

3.无符号右移,忽略符号位,空位都以0补齐

32.形参&实参

33.IO

Java中那些常见概念总结

34.局部变量为什么要初始化

局部变量是指类方法中的变量，必须初始化。局部变量运行时被分配在栈中，量大，生命周期短，如果虚拟机给每个局部变量都初始化一下，是一笔很大的开销，但变量不初始化为默认值就使用是不安全的。出于速度和安全性两个方面的综合考虑，解决方案就是虚拟机不初始化，但要求编写者一定要在使用前给变量赋值。

35.JDK提供的用于并发编程的同步器

36.Java类加载器

一个jvm中默认的classloader有Bootstrap ClassLoader、Extension ClassLoader、App ClassLoader，分别各司其职：

  1. 加载类用的是全盘负责委托机制。 所谓全盘负责，即是当一个classloader加载一个Class的时候，这个Class所依赖的和引用的所有 Class也由这个classloader负责载入，除非是显式的使用另外一个classloader载入。

所以，当我们自定义的classloader加载成功了com.company.MyClass以后，MyClass里所有依赖的class都由这个classLoader来加载完成。

37.Java语言的鲁棒性

Java在编译和运行程序时，都要对可能出现的问题进行检查，以消除错误的产生。它提供自动垃圾收集来进行内存管理，防止程序员在管理内存时容易产生的错误。通过集成的面向对象的例外处理机制，在编译时，Java揭示出可能出现但未被处理的例外，帮助程序员正确地进行选择以防止系统的崩溃。另外，Java在编译时还可捕获类型声明中的许多常见错误，防止动态运行时不匹配问题的出现。

38.Java语言特性

39.Hibernate延迟加载

40.包装类的equals()方法不处理数据转型，必须类型和值都一样才相等。

41.子类可以继承父类的静态方法！但是不能覆盖。因为静态方法是在编译时确定了，不能多态，也就是不能运行时绑定。

42.Java语法糖

43.JVM工具

命令行

可视化

44.内部类为什么可以访问外部类的私有属性

在内部类构造的时候，会将外部类的引用传递进来，并且作为内部类的一个属性，所以内部类会持有一个其外部类的引用。

当内部类调用外部类的私有属性时，其真正的执行是调用了编译器生成的属性的静态方法（即acess1等）来获取这些属性值。这一切都是编译器的特殊处理。

外部类可以通过内部类的实例获取私有属性x的操作.

45.如何让内部类私有成员不被外部访问

使用匿名内部类

public class PrivateToOuter {
  Runnable mRunnable = new Runnable(){
      private int x=10;
      @Override
      public void run() {
          System.out.println(x);
      }
  };

  public static void main(String[] args){
      PrivateToOuter p = new PrivateToOuter();
      //System.out.println("anonymous class private filed= "+ p.mRunnable.x); //not allowed
      p.mRunnable.run(); // allowed
  }
}

由于mRunnable对象的类型为Runnable，而不是匿名内部类的类型（我们无法正常拿到），而Runanble中没有x这个属性，所以mRunnable.x是不被允许的。

46. Java匿名内部类访问外部变量，为何需被标志为final？

47. 非静态内部类为什么不能有静态成员

在外部类并没有实例化，内部类还没有加载，这时候如果调用内部类的静态成员或方法，内部类还没有加载，却试图在内存中创建该内部类的静态成员，这明显是矛盾的。

所以非静态内部类不能有静态成员变量或静态方法。

48. 手写实现二分查找

    /**
 * 使用递归的二分查找
 **title:recursionBinarySearch
 **@param arr 有序数组
 **@param key 待查找关键字
 **@return 找到的位置
 */
public static int recursionBinarySearch( int[] arr, int key, int low, int high )
{
    if ( key < arr[low] || key > arr[high] || low > high )
    {
        return(-1);
    }

    int middle = (low + high) / 2; /* 初始中间位置 */
    if ( arr[middle] > key )
    {
        /* 比关键字大则关键字在左区域 */
        return(recursionBinarySearch( arr, key, low, middle - 1 ) );
    }else if ( arr[middle] < key )
    {
        /* 比关键字小则关键字在右区域 */
        return(recursionBinarySearch( arr, key, middle + 1, high ) );
    }else {
        return(middle);
    }
}
上一篇：解决 APP启动白屏黑屏问题
下一篇：简单理解token机制

相关内容

热门推荐