java知识点总结

本文列举一下java的重要知识点,做一下知识总结和沉淀。

1. JRE、JDK、J2SE、Java SE

  • JRE仅包含运行java程序的必须组件,包括java虚拟机以及java核心类库。

  • JDK同样包含JRE,并且还附带一系列开发、诊断工具,例如jstat、jinfo、jmap、jstack等。

  • J2SE和Java SE,他们指同一个东西,J2SE,J2EE, J2ME更名为Java SE, Java EE, Java ME。J2SE 是java三大技术体系的一个,其他两个是J2EE,J2ME:1)J2SE(Java 2 Standard Edition),标准版技术体系,包含构成了java语言核心的类库,例如,数据库连接,网络编程,接口定义等,主要用于桌面应用软件的开发,包含了JDK的核心类。2)J2EE(Java 2 Enterprise Edition),企业版技术体系,除了包含J2SE中的类,还包含用于开发企业级应用的类,比如,ServerLet,JSP, EJB,主要用于分布式的网络程序开发。3) J2ME(Java 2 Micro Edition),包含J2SE的一部分类,主要用于消费类电子产品的软件开发,比如手机,pad等。

2. 一个java源文件只能有一个public类,源文件的名字必须和public类的名字相同,可以有多个非public类。

3. java的内置类型和其对应的包装类

  • byte:8位,有符号、以二进制补码表示的整数,[-128, 127], 默认值0,对应包装类java.lang.Byte。

  • short:16位,有符号、以二进制补码表示的整数,[-32768, 32767], 默认值0,对应包装类java.lang.Short。

  • int:32位,有符号、以二进制补码标识的整数,[-2147483648, 2147483647], 默认值0,对应包装类java.lang.Integer。

  • long:64位,有符号、以二进制补码表示的整数,[-9223372036854775808,9223372036854775807],默认值0L,L不分大小写,小写容易混淆,对应包装类java.lang.Long。

  • float:单精度,32位浮点数,默认值0.0f,对应包装类java.lang.Float。

  • double:双精度,64位浮点数,浮点数默认类型是double,默认值0.0d,对应包装类java.lang.Double。

  • boolean:表示一位的信息,true/flase, 默认值是false。

  • char:单一的16位的Unicode字符,这点和C++不一样,最小值是\u0000(即为0), 最大值\uffff(即为65536),可以存储任何字符,默认值是'u0000',对应包装类是java.lang.Character。

数据类型从低到高的顺序是byte,short,char—> int —> long—> float —> double,在把大容量的类型转换为小容量类型的时候,必须使用强制类型转换。

4. volatile

volatile修饰的成员变量,在每次被线程访问的时候,都强制从主内存重新读取该成员变量的值,而且当成员变量发生变化的时候,会强制线程将变化值写到主内存,这样任何时刻两个不同的线程总是看到某个成员变量的同一个值。

5. String,StringBuffer,StringBuilder

String类的对象是不可改变,若需要对字符串做多次修改,应该用StringBuffer(线程安全),StringBuilder(线程不安全,从而更快)。

6. String的getBytes方法

byte[]getBytes(),使用平台默认字符集将此String编码为byte序列,

byte[] getBytes(String charsetName),使用指定字符集将此String编码为byte序列。

7. 可变参数

typeName...parameterName ,一个方法中只能指定一个可变参数,且必须是方法的最后一个参数,可以传多个typeName的参数,或者传typeName的数组过来,函数内部都是当作数组使用。

public class VarargsDemo{      
    public static void main(String[]args){      
        printMax(34, 3, 3,2, 56.5);      
        printMax(new double[]{1,2,3});      
    }


    public static void printMax(double...numbers){      
        if(numbers.length == 0)      
        {      
            System.out.println("no argument passed");      
            return;      
        }      
        double result = numbers[0];      
        for (int i = 1; i < numbers.length; ++i)      
        {      
            if(numbers[i] > result){      
                result = numbers[i];      
            }      
        }      
        System.out.println("The max value is " + result);      
    }      
}

8. java的==和equals的用法区别

== 用于检测他们是否是同一个对象,即reference equality;equals 用于检测他们的value是否相等,即逻辑上是否相等:

  • new String("test").equals("test") // --> true;

  • new String("test") == "test" // --> false

  • "test" == "test" // --> true ,这里,常量字符串已经被编译器设置,所以指向同一个对象;

  • "test" == "te" + "st" // --> true,string 常量被编译器设置,所以指向同一个对象

可以用java.util中的Objects程序类,他会检测null:

  • Objects.equals("test", new String("test")) // --> true;

  • Objects.equals(null, "test") // --> false;

  • Objects.equals(null, null) // --> true

绝大多数场景应该用equals, 极少数你认为不会发错的情况下用==(比如就是比较是否是同一个对象,或者被编译器设置的常量)。

9. java内存模型

线程对变量的所有操作(读取、复制)都必须在工作内存中进行,不能直接读写主内存中的变量。不同线程之间不能直接访问对方工作内存中的变量,线程之间变量值的传递均需要在主内存来完成。

10. java线程池

  • newSingleThreadExecutor,如果这个唯一的线程因为异常结束,那么会有一个新的线程代替他,此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

  • newCachedThreadPool,工作线程的创建数量几乎没有限制(integer.MAX_VALUE),这样可灵活的往线程池中添加线程,如果长时间没有往线程池中提交任务,工作线程空闲了1分钟(默认值),该线程将自动终止,终止后若有提交任务,则重新创建工作线程。采用SynchronousQueue装等待的任务,这个阻塞队列没有存储空间,这意味着只要有请求到来,就必须要找到一条工作线程处理他,如果当前没有空闲的线程,那么就会再创建一条新的线程。

  • newFixedThreadPool,创建一个定长线程池,可控制线程最大并发数,超出的任务(Thread对象)会在队列中等待,阻塞队列采用了LinkedBlockingQueue,它是一个无界队列,不会拒绝任务。

  • newScheduledThreadPool,创建一个定长线程池,支持定时及周期任务执行。

11. 字节码翻译成机器码的三种方式:

  • 解释执行,逐条将字节码翻译成机器码并执行,优点:无需等待编译。

  • 即时编译,将一个方法中包含的所有字节码编译成机器码再执行。优点:实际运行速度更快。

  • 混合模式,综合了解释执行和即时编译,会先解释执行字节码,而后将其中反复执行的热点代码,以方法为单位进行即时编译。

即时编译后的java程序执行效率可能是会超过C++的,这是因为与静态编译相比,即时编译拥有程序的运行时信息,并且能根据这个信息做相应优化。

12. C1、C2编译器

  • C1:client编译器,面向的是对启动性能有要求的客户端GUI程序,优化手段相对简单,编译时间短。

  • C2:server编译器,面向的是对峰值性能有要求的服务端程序,优化手段复杂,编译时间长,生成的代码执行效率高。

热点方法首先会被C1编译,而后热点方法中的热点会进一步被C2编译,为了不干扰应用的正常运行,即使编译是放在额外的编译线程进行的。在计算资源充足的情况下,字节码的解释执行和即时编译可同时进行,编译完成的机器码会在下次调用该方法时启用,以替换原本的解释执行。

13. 几个有名的VM

  • Sun HotSpot VM, 默认的java虚拟机,很强大,武林盟主。

  • BEA JRockit, 专注于硬件服务器和服务端应用场景的虚拟机,针对服务端场景做了很多优化,因此其不太关注程序启动速度。JRockit虚拟机内部不包含解释器实现,全部代码都靠即使编译器编译后执行。

  • IBM J9 VM:通用的虚拟机,从服务端到桌面应用,再到嵌入式都可以。

  • Azul VM 和 BEA Liquid VM 的专用商业及虚拟机:只运行在特定硬件平台,要求比较高,性能也很强悍,可以管理至少数十个CPU和数百GB的内存,还提供巨大内存范围内实现可控GC时间的垃圾收集器。

14. java虚拟机执行class字节码的过程

  • 加载:把代码数据加载到内存中,接着为这个类在JVM的方法区创建一个对应的class对象,这个class对象就是这个类各种数据的访问接口。

  • 验证:JVM规范校验,代码逻辑校验等。

  • 准备:Java 中的变量有「类变量」和「类成员变量」两种类型,「类变量」指的是被 static 修饰的变量,而其他所有类型的变量都属于「类成员变量」。在准备阶段,JVM 只会为「类变量」分配内存,而不会为「类成员变量」分配内存。「类成员变量」的内存分配需要等到初始化阶段才开始。

  • 解析:JVM针对类、接口、字段、类方法、接口方法、方法类型、方法句柄、调用点限定符7类引用进行解析,将常量池中的符号引用替换成直接其在内存中的直接引用。

  • 初始化:JVM 会根据语句执行顺序对类对象进行初始化。

  • 使用:JVM完成初始化后,从入口方法开始执行用户的程序代码。

  • 卸载:当用户代码执行完毕后,JVM便开始销毁创建的class对象,最后负责运行的JVM也退出内存。

15. 直接内存

NIO(New Input/Output)类,引入基于通道(Channel)和缓冲区(Buffer)的I/O方式,可以使用Native函数库直接分配堆外内存,然后通过存储在java堆中的DirectByteBuffer对象作为这块内存的引用进行操作,能显著提升性能,避免了在java堆和native堆中来回复制数据。本机直接内存的分配不会受到java堆大小的限制,但是会受到本机总内存的大小以及处理器寻址空间的限制。在-Xmx等参数的设置,需要考虑到直接内存,避免两者总量大于本机内存,从而导致动态扩展的时候出现OutOfMemoryError异常。

16. 如何判断对象是垃圾

  • 引用计数法,对象被引用时加1,被去引用时减1,通过判定引用计数是否为0来判断对象是否是垃圾,这有个缺陷,对循环引用没有办法。

  • GC Root Tracing,从GC Root 出发,所有可达的对象都是存活的,所有不可达的对象都是垃圾。Golang采用了三色标记法,思路差不多:1)起初所有对象都是白色的,2)从根出发扫描所有可达对象,标记为灰色,放入待处理队列。3)从队列取出灰色对象,将其引用对象(从白色里面挑选)标记为灰色放入队列,自身标记为黑色。4)重复3,直到灰色对象队列为空,此时白色对象即为垃圾,进行回收。

17. 垃圾回收算法

  • 标记清除算法:分标记、清除两个阶段,标记阶段标记所有GC Root可达的对象,清除阶段清理掉所有未标记的对象,存在空间碎片问题,影响后续对象的分配效率。

  • 复制算法:将原有空间分成2块,每次只使用一块,每次垃圾回收的时候将存活的对象拷贝到另外一块,然后将原先的一块清理掉,然后交换2块的角色,空间只能使用1块,折损太大。

  • 标记压缩算法:分标记、压缩两个阶段,标记阶段标记所有存活的对象,压缩阶段,将所有存活的对象压缩到内存的一边,然后清理边界外的所有空间,移动和压缩会影响应用程序。

18. 新生代、老年代各自采用的回收算法

  • 新生代,大部分是存活很短的,若用标记清除算法则会有大量碎片,采用复制算法较好,但是也要注意,并不是对半分的,采用Eden:From Suvior0:To Suvior1=8:1:1分发,对象优先分配在Eden、From Survior0中,少量存活的复制到To Suvior1 中, 这种情况,只浪费了10%的空间,若ToSuvior1放不下Eden、From Survior0的存活对象,则会借用老年代的内存(分配担保)。

  • 老年代,标记清除算法、标记压缩,因为对象存活时间长,只有少量的对象需要清除或者标记,不会有大量的内存碎片;反过来,若用复制算法,则需要移动大量的对象,会严重影响应用程序。

19. 垃圾回收器

  • 串行回收器,用单线程进行垃圾回收的回收器,每次只有一个线程,在并发能力较弱的计算机上,其专注性和独占性的特点可以让其有较好的性能表现,可以在新生代和老年代使用,分为新生代串行回收器和老年代串行回收器。

  • 并行回收器,用多线程处理,对于并行能力强的机器,可以有效缩短垃圾回收所用时间:1)新生代ParNew回收器,将串行回收器多线程化,其回收策略、算法、参数和新生代串行回收器一样,在并行能力强的机器可以缩短垃圾回收时间,在并行能力弱的机器,由于存在线程切换,性能不一定比串行好。2)新生代ParallelGC回收器,与新生代ParNew回收器类似,也采用复制算法,多线程、独占式的,会导致stop-the-world,但是不同点是:注重系统的吞吐量,自适应调节策略,-XX:UseAdaptiveSizePolicy, 打开此策略,新生代的大小、Eden和Survior的比例、晋升老年代的对象的年龄等参数会自动调节,达到堆大小、吞吐量、停顿时间的平衡。-XX:MaxGCPauseMillis:设置最大垃圾收集器停顿时间,在ParallelGC工作期间,自动调整相应参数,将停顿时间控制在设置范围内,为完成此目标,会用较小的堆,从而也会导致频繁GC,-XX:GCTimeRatio:设置吞吐量大小,0~100的整数,假设为n,则系统将不花费超过1/(1+n)的时间用于垃圾收集,默认值是99,即不超过1%的时间用于垃圾收集。3)老年代ParallelOldGC回收器,注重吞吐量的回收器,多线程并发,因为是作用在老年代,算法用的标记压缩算法。

  • CMS回收器,主要关注系统停顿时间,Concurrent Mark Sweep, 标记清除法(会造成内存碎片),多线程并行回收的垃圾回收器。

  • G1 回收器,使用了分区算法,从而使得Eden区、From区、Survior区、老年代等各内存可以不用连续。分为初始标记,根区域扫描,并发标记,重新标记,独占清理,并发清理6个阶段,其中初始标记、重新标记、独占清理是独占式的,会stop-the-world,所有待回收的内存放到Collection Set中,首先针对Collection Set中的内存进行回收,当内存不足的时候,可能会触发FullGC。

20. HashMap和ConcurrentHashMap

  • HashMap,非线程安全,不能用于并发,在JDK1.7,采用数组+链表的方式,根据Key,Hash之后得到应该存放的桶的位置,若桶是空,则直接放进去,若桶是链表,则顺着链表进行查找,若没有则在最后添加,若有,则直接覆盖。当Key冲突较大的情况下,链表的长度会很长,降低了读写的效率。JDK1.8版本,有一个阈值,默认值是8,用于判定是否需要将链表转换成红黑树。

  • ConcurrentHashMap,JDK1.7版本采用分段锁技术,比Hashtable锁的粒度要细,支持Segment数量的线程并发。Hashtable不支持多线程间增加、迭代访问,迭代器会失效。ConcurrentHashMap支持此种场景,迭代器不会失效。用自旋锁+阻塞锁机制,先自旋锁,超过一定的重试次数后,改为阻塞锁。自旋锁一般用于竞争不频繁的场景,使用不当会造成CPU的浪费,优势是没有发生用户态、内核态的切换,效率高。与HashMap不同的是,ConcurrentHashMap最外层不是一个大的数组,而是一个Segment的数组。每个Segment包含一个与HashMap数据结构差不多的链表数组。JDK1.8版本摒弃了分段锁的方案,而是直接使用一个大的数组,对于PUT操作,如果Key对应的数组元素为NULL,则通过CAS操作将其设置为当前值。如果Key对应的数组元素(也即链表表头或者树的根元素)不为NULL,则对该元素使用synchronized关键字申请锁,然后进行操作。和HashMap一样,如果链表长度超过一定阈值,则会将其转成红黑树。

// JDK1.7版本结构
static final class HashEntry<K,V>{    
    final int hash;    
    final K key;    
    volatile V value;    
    volatile HashEntry<K, V> next;    
}    
static final class Segment<K, V> extends ReentrantLock implements Serializable{        
      private static final long serialVersionUID = 2249069246763182397L;        
      transient volatile HashEntry<K,V>[] table;        
      transient int count;        
      transient int modCount;        
      transient int threshold;        
     transient int loadFactor;        
}        
 final Segment<K, V> [] segments

21. synchronized的用法以及底层实现

  • 可以锁静态方法(含static),其锁的是类的class对象(不同于类的实例对象),可以控制这个类的多个静态方法的互斥访问。这时若有一个synchronized 锁的是非static方法(锁的是类的实例对象),两者是不互斥的,多线程可以同时访问,因为锁的对象是不一样的。

  • 可以锁代码块,锁的对象可以指定,比如某个实例对象,或者类的class对象。

java虚拟机中的同步(synchronized)基于进入和退出管程(monitor)对象实现。包括显示同步(同步代码块,有明确monitorenter和monitorexit指令)和隐示同步(synchronized 修饰的同步方法,无monitorenter和monitorexit,由方法调用指令读取运行时常量池中的方法的ACC_SYNCHRONIZED标志来隐示实现)。

在JVM中,对象在内存中的布局分为三块区域:实例数据,对齐填充,对象头。

  • 实例数据:存放类的属性数据信息,包括父类的属性信息,如果是数组的实例部分,还包括数组的长度,这部分内存按4字节对齐。

  • 填充数据:虚拟机要求对象的起始地址是8字节的整数倍,故有时候需要对齐字节。

  • 对象头:这是实现synchronized的锁对象的基础,主要由Mark Word和Class Metadata Address组成。

synchronized 是可重入的,比如,一个synchronized(锁的是实例的对象)方法可以调用另外一个synchronized方法。

synchronized与等待唤醒:

  • 对象的wait/notify/notifyall 必须在synchronized 方法(或者代码块中)执行。

  • 和sleep方法不同,调用sleep方法,只是让对应线程休眠,并未释放对应的锁。

  • 调用wait方法后,会释放对应的锁,直到有人调用notify/notifyall方法才会继续。

  • 调用notify/notifyall方法后不会立即释放锁,等相应的方法和代码块执行完毕才会释放。

java对synchronized的优化:

  • 锁的状态:无锁状态,偏向锁,轻量级锁,自旋锁,重量级锁,随着锁的竞争,锁可以从低到高单向升级。

  • 偏向锁:如果一个线程获得了锁,那么锁就进入偏向模式,当这个线程再次请求锁时,无需做任何同步操作,即省去了大量有关锁的申请操作,提高了程序的性能。若失败则升级为轻量级锁。

  • 轻量级锁:适应的场景是线程交替执行同步块的情况,如果存在同一时间访问同一锁的情况,就会导致轻量级锁膨胀为自旋锁。

  • 自旋锁:先尝试自旋几次,若得到锁,则进入临界区,若不能得到锁,则升级为为重量级锁。

  • 重量级锁:即真正意义上的锁,会将线程在操作系统层面挂起(发生用户态到内核态的切换)。

锁消除:由JIT编译器识别,部分逻辑代码完全不会存在线程共享访问,可以将对应的锁逻辑去掉。比如下面的StringBuffer类,append是同步方法(含synchronized),但是sb变量是局部变量,完全不会有数据共享问题,所以会将对应的锁消除掉。

public void add (String str1, String str2){
    StringBuffer sb = new StringBuffer();
    sb.append(str1).append(str2);
}

22. lombook

lombook是一个开源项目,能够通过添加注解自动生成一些方法,这个包是在编译阶段起作用,免去一些常规小函数的编写,例如,@Getter/@Setter注解可以针对类的属性字段自动生成Get/Set方法。

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.16.8</version>
</dependency>

23. JDK性能监控工具

jstat -<option> [-t]  [-h<lines>  <vmid>  [<interval> [<count>]]

option 可以由以下值构成:

-class, 监视类装载、卸载数量、总空间、以及类装载所耗费的空间            
-gc,监视java堆的情况,包括Eden区、两个Survior区、老年代、永久代的容量、已使用空间、GC时间合计等信息            
-gccapacity,监视内容基本和-gc相同,增加输出java堆各个区的最大、最小空间            
-gcutil,基本和-gc相同,主要关注已使用空间占总空间的百分比            
-gccause, 与-gcutil相同,额外输出导致上一次GC的原因            
-gcnew, 监视新生代的GC状况            
-gcnewcapacity,基本与-gcnew一样,主要关注使用到的最大、最小空间            
-gcold, 监视老年代GC状况            
-gcoldcapacity, 与-gcold基本一样,关注使用到的最大、最小空间            
-gcpermcapacity,输出永久代的最大、最小空间            
-compiler, 输出JIT编译器编译过的方法、耗时信息            
-printcompilation 输出JIT编译过的方法  

-t ,表示输出时间戳

-h,表示在多少行后输出一个表头

vmid, 虚拟机的进程ID

interval,输出间隔, 单位是毫秒

count,输出次数

举例,

[[email protected] /usr/local/services/jdk1_8_0_111-1.0/jdk1.8.0_111/bin]# ./jstat -gcutil  -h1000  -t 32160 10000 1                
Timestamp         S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT                
       172641.0   0.00  31.79  50.93  13.92  97.22  95.73   1977    8.763     0    0.000    8.763


S0:Survior 0 ,还未使用                
S1:Survior 1, 使用了31.79%,                 
E:Eden, 使用了50.93%                
O:老年代使用了13.92%                
M: 元空间使用了97.22%                              
YGC、YGCT:程序运行以来,共发生1977次Minor GC,总共耗时8.763秒                
FGC/FGCT: 程序运行以来,共发生0次FullGC,耗时0秒                
GCT:总的GC的耗时,这里是YGCT+FGCT=8.763秒

24. 堆栈空间的设置参数

  • -Xms:堆得初始空间大小。

  • -Xmx:堆的最大空间大小。

  • -Xmn:设置年轻代的内存大小, ms(mx) - mn的大小就是老年代的大小。

  • -XX:SurviorRatio= eden/from =eden/to,from和to, 同一时间只有一个可用,循环作为from或者to,即始终有一个是浪费的。

  • -Xss:栈空间大小。

  • -XX:PermSize:永久代初始大小,一般是用来存放方法的,1.8用元空间代替。

  • -XX:MaxPermSize:永久代的最大大小。

  • -XX:MetaSpaceSize:元空间发生发生GC的阈值。

  • -XX:MaxMetaSpaceSize:设置元空间的最大大小,默认基本是机器的物理内存大小。

  • -XX:MaxDirectMemorySize, 指定本机直接内存的容量,若不指定,则默认与java堆的最大值保持一致(-Xmx), NIO的方法可能会用到此块内存。

版权声明:本文为jameswhale原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/jameswhale/article/details/106668548

智能推荐

运用for语句来判断数组中值得大小

总结: 1将if语句与数组联合起来判断输入中各组中的最大最小值; 2注意:定义的数组数量是躲多少就要输入多少组数据,少输入就无法输出;...

Bridging signals

Bridging signals Time Limit: 1000MSMemory Limit: 10000K Total Submissions: 10926Accepted: 5982 Description 'Oh no, they've done it again', cries the chief designer at the Waferland chip factory. Once ...

一天一大 leet

一天一大 leet 题目(难度:困难): 示例 抛砖引玉 官方答案 高手在民间 菜鸡的自白 20200606 题目(难度:困难): 给定一个未排序的整数数组,找出最长连续序列的长度。 要求算法的时间复杂度为 O(n)。 示例 示例 抛砖引玉 要求算法的时间复杂度为 O(n),即限制了只能循环一次; 先对数组排序 循环数组记录后一个元素等于前一个元素+1或者等于前一个元素的数量 满足条件++,不然重...

Tensorflow实现的CNN文本分类

https://blog.csdn.net/somtian/article/details/69359498 原博文, github 在这篇文章中,我们将实现一个类似于Kim Yoon的卷积神经网络语句分类的模型。 本文提出的模型在一系列文本分类任务(如情感分析)中实现了良好的分类性能,并已成为新的文本分类架构的标准基准。 本文假设你已经熟悉了应用于NLP的卷积神经网络的基础知识。 如果没有,建议...

JDBC新手入门教程

开发工具:idea 数据库:mysql jar包:junit-4.10 mysql-connector-java-8.0.18 junit-4.10下载 mysql-connector-java-8.0.18下载 注意1:jdbc的驱动因为使用的是mysql-connector-java-8.0.18,所以为(“com.mysql.cj.jdbc.Driver”),而不是(...

猜你喜欢

Lua 排序 table.sort

    正如C#中有Array.Sort(),lua中也有自己的排序方法即table.sort(table,function)。     lua中的排序默认是从大到小的排序;     传入一个方法参数,可以使排序从小到大; 打印结果:  ...

SURF算法简述及Python标记SURF特征检测实践

目录 一、SURF算法 1.算法简介 2.SURF与SIFT的具体差异 二、Python代码实践 1.测试环境 2.测试代码 3.核心函数 4.测试结果 一、SURF算法 1.算法简介 SURF(Speeded-Up Robust Features)加速稳健特征,是一种稳健的局部特征点检测和描述算法。 SURF是对SIFT算法的改进,该算子在保持 SIFT 算子优良性能特点的基础上,同时解决了 S...

Selenium3自动化测试——19.读取数据文件

1. 实现目标 在测试与开发中,经常需要对文件进行各种读取操作。这里介绍针对txt、csv、xml、json文件的读取。 2. 读取TXT文件 2.1 user_info.txt文件 2.2 读取txt文件.py 2.3 实现结果 3. 读取csv文件 3.1 user_info.csv  这里要注意,csv文件本身打开是utf-8的,而不是乱码 3.2 读取csv文件.py 这里,针对...

Flask 介绍

Flask 学习笔记 一、Flask 简介         Flask 是一款非常流行的 Python Web 框架,出生于 2010 年,作者是 Armin Ronacher,本来这个项目只是作者在愚人节的一个玩笑,后来由于非常受欢迎,进而成为一个正式的项目。         Flask 自2010年发布第一个版本以...

Java实现十大排序算法,配合动态图片

Java实现排序算法 其中不理解时间复杂度得可以看一下我的时间复杂度的文章,有助于理解 十大排序算法 1、冒泡排序 2、选择排序 3、插入排序 4、希尔排序 5、归并排序 6、快速排序 7、堆排序 8、计数排序 9、桶排序 10、基数排序 代码git地址:https://github.com/gaoyeming/sort-algorithm.git 排序算法说明 1,排序的定义 对一序列对象或者数...