8504560170

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head==null){
            return null;
        }
        ListNode c,n,p;
        c=head;
        n=head.next;
        head.next=null;
        while(n!=null){
            p = n.next;
            n.next=c;
            c=n;
            n=p;
        }
        return c;
    }
}

思路:使用三个指针,当前节点c,下一节点n,使用一个中间变量p存储下一节点的下一个节点。初始时头节点head的下一节点置为空,使用p存储节点n的下一节点值,节点n的下一节点指向当前节点c,当前节点后移c=n,n后移指向p。

zoetic

man:查找shell命令手册

    Linux将文件存储在单个目录结构中,这个目录被称为虚拟目录( virtual directory)。虚拟目录将安装在 PC上的所有存储设备的文件路径纳入单个目录结构中。Linux虚拟目录结构只包含一个称为根( root)目录的基础目录。根目录下的目录和文件会按照访问它们的目录路径一一列出。

绝对文件路径

相对文件路径

文件和目录列表

ls:当前目录下的文件和目。

-F:区分文件和目录。

-a:隐藏文件和普通文件及目录一起显示出来。

-R:递归输出子目录。

-l:输出详细信息。

创建文件

touch:创建空文件

复制文件

cp source destination

链接文件

链接文件是Linux 文件系统的一个优势。如需要在系统上维护同一文件的两份或多份副本,除了保存多份单独的物理文件副本之外,还可以采用保存一份物理文件副本和多个虚拟副本的方法。这种虚拟的副本就称为链接 。链接是目录中指向文件真实位置的占位符。在Linux 中有两种不同类型的文件链接:

     符号链接

    ln -s source target

创建一个新文件,inode是新的,文件存放的是源文件的路径,相当于快捷方式

     硬链接

    硬链接是采用对inode代表文件引用计数的方式对文件进行链接,对任一链接文件进行修改都会直接影响到全部链接文件,而删除某一链接文件,不会影响其它链接文件的内容,但是文件的引用计数会-1,除非引用计数为0,否则inode所代表的文件不会被删除。

重命名文件

mv source target

删除文件

rm

-i:询问提示符

-f:强制删除

-r:递归删除子文件,再删除目录

创建目录

mkdir

-p:同时创建目录和子目录

删除目录

rmkdir

查看文件类型

file

查看文件内容

cat:所有内容都显示出来

more :分页显示

less:more的升级版

tail:从文件尾开始查看
-f:可以监控其他进程对文件的修改,用来做日志监控

head:从文件头开始查看

 

 

 

(908) 553-1603

Linux分为四部分:

1、Linux内核

2、GNU工具

3、图形化桌面环境

4、应用软件

一、内核

控制计算机系统所有软件和硬件,分配硬件,根据需要执行软件。

功能:

1、内存管理

物理内存+虚拟内存,虚拟内存借用硬盘空间来扩展内存,这片内存成为交换空间。内存存储单元按组分成多个块,这些块称作页面。内核会维护一个内存页面表,内核会记录哪些内存页面正在使用中,并自动把一段时间未访问的内存页面复制到交换空间区域(称为换出 ,swapping out )——即使还有可用内存。当程序要访问一个已被换出的内存页面时,内核必须从物理内存换出另外一个内存页面给它让出空间,然后从交换空间换入请求的内存页面。

2、软件程序管理

Linux操作系统将运行中的程序称为进程。内核创建了第一个进程(称为init进程 )来启动系统上所有其他进程。当内核启动时,它会将init 进程加载到虚拟内存中。内核在启动任何其他进程时,都会在虚拟内存中给新进程分配一块专有区域来存储该进程用到的数据和代码。

3、硬件设备管理

设备驱动程序:应用程序和硬件设备的中间人,允许内核与设备之间交换数据。

两种方法加入驱动程序:

         编译进内核的设备驱动代码

         可插入内核的设备驱动模块

    Linux系统将硬件设备当成特殊的文件,称为设备文件。设备文件有 3种分类:

         字符型设备文件

         块设备文件

         网络设备文件

字符型设备文件是指处理数据时每次只能处理一个字符的设备。大多数类型的调制解调器和终端都是作为字符型设备文件创建的。

块设备文件是指处理数据时每次能处理大块数据的设备,比如硬盘。

网络设备文件是指采用数据包发送和接收数据的设备,包括各种网卡和一个特殊的回环设备。这个回环设备允许 Linux系统使用常见的网络编程协议同自身通信。

    4、文件系统管理

    Linux内核采用虚拟文件系统( Virtual File System, VFS)作为和每个文件系统交互的接口。这为 Linux内核同任何类型文件系统通信提供了一个标准接口。当每个文件系统都被挂载和使用时, VFS将信息都缓存在内存中。

二、GNU工具

执行一些标准功能,比如控制文件和程序。

    GNU coreutils软件包由三部分构成:

         用以处理文件的工具

         用以操作文本的工具

         用以管理进程的工具

    shell:为用户提供了启动程序、管理文件系统中的文件以及运行在Linux 系统上的进程的途径。shell 的核心是命令行提示符。命令行提示符是shell 负责交互的部分。它允许你输入文本命令,然后解释命令,并在内核中执行。

 

WebService

解决跨平台跨语言的数据交互问题,使用一套统一的标准,xml作为数据交互载体,使用http协议传输数据。 所谓跨编程语言和跨操作平台,就是说服务端程序采用java编写,客户端程序则可以采用其他编程语言编写,反之亦然!跨操作系统平台则是指服务端程序和客户端程序可以在不同的操作系统上运行。

SOAP协议 = HTTP协议 + XML数据格式

WSDL(Web Services Description Language)基于XML的语言,用于描Web Service及其函数、参数和返回值。它是WebService客户端和服务器端都 能理解的标准格式。

    WebService 的工作调用原理

    对客户端而言,我们给这各类WebService客户端API传递wsdl文件的url地址,这些API就会创建出底层的代理类,我调用 这些代理,就可以访问到webservice服务。代理类把客户端的方法调用变成soap格式的请求数据再通过HTTP协议发出去,并把接收到的soap 数据变成返回值返回。对服务端而言,各类WebService框架的本质就是一个大大的Servlet,当远程调用客户端给它通过http协议发送过来 soap格式的请求数据时,它分析这个数据,就知道要调用哪个java类的哪个方法,于是去查找或创建这个对象,并调用其方法,再把方法返回的结果包装成 soap格式的数据,通过http响应消息回给客户端。

semireligious

public static void main(String[] args){
    StringBuilder stringbuilder = new StringBuilder();
    Scanner scanner = new Scanner(System.in);
    while(true)
    {
        String text = scanner.nextLine().trim();
        if ("".equals(text))
        {
            break;
        }
        stringbuilder.append(text);
    }
    System.out.println(stringbuilder.toString());
}

628-205-3994

mac下的google drive无法识别http以外的proxy,因此需要使用proxifier将其转化为socks5代理

配置proxifier

1、添加proxies

端口配置为跟ss相同的端口

2、配置rules

主要为你的某个应用配置代理,这里让googledrive的请求转化为socks

配置成功后,打开googledrive就会见到相关请求的数据包成功传输

note:ss的模式不能使用pac,用acl,卡在这里半天,原因是pac只对http协议相关规则有效,则对于转换为socks5协议的请求会拦截,acl貌似是升级版的pac,对底层协议有效!

单例模式

饿汉式:空间换时间,类加载的时候就初始化

public class EagerSingleton{
    private static EagerSingleton instance = new EagerSingleton();
    private EagerSingleton(){}
    public static EagerSingleton getInstance(){
        return instance;
    }
}

懒汉式:时间换空间,需要的时候才创建,但在多线程环境下需要同步,每次都要加锁判断。

public class LazySingleton{
    private static LazySingleton instance = null;
    private LazySingleton(){}
    public static synchronized LazySingleton getInstance(){
        if(instance==null)
            return new LazySingleton();
    }
}

双重检查加锁

可以使用“双重检查加锁”的方式来实现,就可以既实现线程安全,又能够使性能不受很大的影响。那么什么是“双重检查加锁”机制呢?
所谓“双重检查加锁”机制,指的是:并不是每次进入getInstance方法都需要同步,而是先不同步,进入方法后,先检查实例是否存在,如果不存在才进行下面的同步块,这是第一重检查,进入同步块过后,再次检查实例是否存在,如果不存在,就在同步的情况下创建一个实例,这是第二重检查。这样一来,就只需要同步一次了,从而减少了多次在同步情况下进行判断所浪费的时间。
“双重检查加锁”机制的实现会使用关键字volatile,它的意思是:被volatile修饰的变量的值,将不会被本地线程缓存,所有对该变量的读写都是直接操作共享内存,从而确保多个线程能正确的处理该变量。

public class Singleton{
    private volatile static Singleton instance =null;
    private Singleton(){}
    public Singleton getInstance(){
        if(instance = = null)
            synchronized(Singleton.class){
                if(instance == null)
                    instance = new Singleton();
            }
        return instance;
    }
}

Lazy initialization holder class模式

这个模式综合使用了Java的类级内部类和多线程缺省同步锁的知识,很巧妙地同时实现了延迟加载和线程安全。
1.相应的基础知识

–  什么是类级内部类?

简单点说,类级内部类指的是,有static修饰的成员式内部类。如果没有static修饰的成员式内部类被称为对象级内部类。
类级内部类相当于其外部类的static成分,它的对象与外部类对象间不存在依赖关系,因此可直接创建。而对象级内部类的实例,是绑定在外部对象实例中的。
类级内部类中,可以定义静态的方法。在静态方法中只能够引用外部类中的静态成员方法或者成员变量。
类级内部类相当于其外部类的成员,只有在第一次被使用的时候才被会装载。

–  多线程缺省同步锁的知识

大家都知道,在多线程开发中,为了解决并发问题,主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中,JVM已经隐含地为您执行了同步,这些情况下就不用自己再来进行同步控制了。这些情况包括:
1.由静态初始化器(在静态字段上或static{}块中的初始化器)初始化数据时
2.访问final字段时
3.在创建线程之前创建对象时
4.线程可以看见它将要处理的对象时
2.解决方案的思路

要想很简单地实现线程安全,可以采用静态初始化器的方式,它可以由JVM来保证线程的安全性。比如前面的饿汉式实现方式。但是这样一来,不是会浪费一定的空间吗?因为这种实现方式,会在类装载的时候就初始化对象,不管你需不需要。
如果现在有一种方法能够让类装载的时候不去初始化对象,那不就解决问题了?一种可行的方式就是采用类级内部类,在这个类级内部类里面去创建对象实例。这样一来,只要不使用到这个类级内部类,那就不会创建对象实例,从而同时实现延迟加载和线程安全。
示例代码如下:

public class Singleton {

    private Singleton(){}

    /**

    * 类级的内部类,也就是静态的成员式内部类,该内部类的实例与外部类的实例

    * 没有绑定关系,而且只有被调用到时才会装载,从而实现了延迟加载。

    */

    private static class SingletonHolder{

    /**

    * 静态初始化器,由JVM来保证线程安全

    */

    private static Singleton instance = new Singleton();

    }

    public static Singleton getInstance(){

        return SingletonHolder.instance;

    }

}

当getInstance方法第一次被调用的时候,它第一次读取SingletonHolder.instance,导致SingletonHolder类得到初始化;而这个类在装载并被初始化的时候,会初始化它的静态域,从而创建Singleton的实例,由于是静态的域,因此只会在虚拟机装载类的时候初始化一次,并由虚拟机来保证它的线程安全性。
这个模式的优势在于,getInstance方法并没有被同步,并且只是执行一个域的访问,因此延迟初始化并没有增加任何访问成本。