个人java笔试笔记

一.例如牛客杨辉三角问题 

    （1）可以考虑找规律的方法解决

    （2）常规方法

    链接：https://www.nowcoder.com/questionTerminal/8ef655edf42d4e08b44be4d777edbf43

二.字符

    

Character 方法

下面是Character类的方法：

序号	方法与描述
1	isLetter() 是否是一个字母
2	isDigit() 是否是一个数字字符
3	isWhitespace() 是否是一个空格
4	isUpperCase() 是否是大写字母
5	isLowerCase() 是否是小写字母
6	toUpperCase() 指定字母的大写形式
7	toLowerCase() 指定字母的小写形式
8	toString() 返回字符的字符串形式，字符串的长度仅为1

 

三.关于字符串

 

   （1）关于java正则表达式的匹配

      http://www.runoob.com/java/java-regular-expressions.html

String regexaA="[a-zA-Z]+";  
    Matcher aA=Pattern.compile(regexaA).matcher(input); 
    if(aA.matches())
    	z+=20;

   （2）字符串

           单引号引的数据 是char类型的
           双引号引的数据 是String类型的 

          String类适用于描述字符串事物。
         那么它就提供了多个方法对字符串进行操作。
 
         常用的方法如下：
 
 1、获取：
  1.1 字符串中包含的字符数，也就是字符串的长度。
  int length():获取长度。
  1.2 根据位置获取该位置上的某个字符。
  char charAt(int index):返回指定索引处的char值。
  1.3 根据字符获取该字符在字符串的位置。
  int indexOf(String str):返回的是str在字符串中第一次出现的位置。
  int indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。
  int lastIndexOf(int ch):反向索引一个字符出现的位置
 
 2、判断：
  2.1  字符串中是否包含某一个子串。
  boolean contains(str);
  特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1表示该str不在字符串中存在。
    所以，也可以用于对指定判断是否包含。
  if(str.indexOf("aa")!=-1)  
    而且该方法既可以判断，又可以获取出现的位置
  2.2 字符中是否有内容。
  boolean isEmpty():原理就是判断长度是否为0.
  2.3 字符串是否是以指定内容开头。
  boolean startsWith(str);
  2.4 字符串是否是以指定内容结尾。
  boolean endsWith(str);
  2.5判断字符串内容是否相同。复写Object类中的equals方法。
  boolean equals(str);
  2.6 判断内容是否相同，并忽略大小写
  boolean equalsIgnoreCase();
 
 3、转换
  3.1 将字符数组转换成字符串。
  构造函数： String(char[])
    String(char[],offset,count):将字符数组中的一部分转换成字符串。
  静态方法：
  static String copyValueOf(char[]);
  static String copyvalueOf(char[] data, int offset, int count);
  3.2 将字符串转换成字符数组（重点）。
  char[] toCharArray();
  3.3 将字节数组转换成字符串。
  String(byte[])
  String(byte[],offset,count):将字节数组中的一部分转换成字符串。
  3.4 将字符串转换成字节数组
  3.5 将基本数据类型转换成字符串。
  String valueOf(int);  //String ch=String.valueOf(Password.charAt(i));
  String valueOf(double);
 
  特殊：字符串和字节数组在转换过程中是可以指定编码表的。
 
 4、替换
  String replace(oldchar,newchar);
 5、切割
  String[] split(regex);
 6、子串            获取字符串中的一部分
  String substring(begin);
  String substring(begin,end);
 7、转换，去除空格，比较
  7.1 将字符串转成大写或者小写。
  String toUpperCase();
  String toLowerCase();
  7.2 将字符串两端的多个空格去除。
  String trim();

  7.3 将两个字符串进行自然顺序的比较。

参考https://blog.csdn.net/u012369373/article/details/49894551

排序 https://www.cnblogs.com/onepixel/articles/7674659.html

快排http://developer.51cto.com/art/201403/430986.htm

 

JVM的内存结构，JVM的算法
JVM内存结构主要有三大块：堆内存、方法区和栈，几乎所有的对象实例都存放在堆里，如果在堆中没有内存完成实例分配，并且堆也无法再扩展时，将会抛出OutOfMemoryError异常。
方法区用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据，当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常。
每个方法被执行的时候都会同时创建一个栈帧（Stack Frame）用于存储局部变量表、操作栈、动态链接、方法出口等信息。
每一个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。 
如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常。
 

2.1.1 单例(Singleton)
确保一个类只有一个实例，并提供一个全局的访问点。 
需要注意的是，多个类加载器下使用单例，会导致各类加载器下都有一个单例实例，因为每个类加载器都有自己独立的命名空间。 
JDK 中的单例有 Runtime.getRuntime()、NumberFormat.getInstance() 
下面总结了四种线程安全的 Java 实现方法。每种实现都可以用 Singleton.getInstance().method(); 调用。

2.1.1.1 饿汉方式
关键思路：作为类的静态全局变量，加载该类时实例化。 
缺点是真正使用该实例之前（也有可能一直没用到），就已经实例化，浪费资源。 
对于 Hotspot VM，如果没涉及到该类，实际上是首次调用 getInstance() 时才实例化。

 

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {
    }

    // 基于 classLoader 机制，自动达到了线程安全的效果
    public static （synchronized） Singleton getInstance() {
        return instance;
    }

    public void method() {
        System.out.println("method() OK.");
    }
}
 

2.1.3 简单工厂(Simple Factory) ★
不是真正的“设计模式”。自身是工厂实现类，直接提供创建方法(可多个)，可以是静态方法。JDK 中有 Boolean.valueOf(String)、Class.forName(String)。

/**
 * @author: kefeng.wang
 * @date: 2016-06-09 19:42
 **/

public class DPC3_SimpleFactoryPattern {
    private static class SimpleFactory {
        public CommonProduct createProduct(int type) { // 工厂方法，返回“产品”接口，形参可无
            if (type == 1) {
                return new CommonProductImplA(); // 产品具体类
            } else if (type == 2) {
                return new CommonProductImplB();
            } else if (type == 3) {
                return new CommonProductImplC();
            } else {
                return null;
            }
        }
    }

    private static class SimpleFactoryClient {
        private SimpleFactory factory = null;

        public SimpleFactoryClient(SimpleFactory factory) {
            this.factory = factory;
        }

        public final void run() {
            CommonProduct commonProduct1 = factory.createProduct(1);
            CommonProduct commonProduct2 = factory.createProduct(2);
            CommonProduct commonProduct3 = factory.createProduct(3);
            System.out.println(commonProduct1 + ", " + commonProduct2 + ", " + commonProduct3);
        }
    }

    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory(); // 工厂实例
        new SimpleFactoryClient(factory).run(); // 传入客户类
    }
}