2020-10-29 变量基础

1.局部变量

局部变量用来临时保存数据（在类的方法中定义），只能在当前方法中使用，没有初始值，所以必须赋值，在该方法当中不可以出现拥有相同名称的局部变量；

public class Test {
	public static void main(String[] args) {
		int num = 10;
	}
}

局部变量的内存空间和值都存储在栈内存当中。赋值应该就是把操作数栈中的值写到局部变量表中。它们都在VM stack中。

在我们的基本数据类型当中，全局变量时拥有默认值的

整型：0

浮点型：0.0

boolean:flase

char类型：空

二、常量

在java当中，利用关键值final表示常量。

public class Constants {

final int NUM = 10;

public static void main(String[] args) {

}

}

关键字final表示这个变量只能被赋值一次。一旦被赋值后，就不需要在更改了。习惯上，常量名使用全大写，被fianl定义的常量一旦赋值就不可以更改。

 

 

值得一提的是，仅包含前三种类型byte，short和char任意两种类型的运算在参与运算时会自动转换为int后再进行运算，此时最终数值会变成int类型，如果不止仅前三种数值参与运算，最开始说的向最高级转换的规则依然成立，我把它们概括为“下三滥”，弱者是没有权利的，只能向int看齐，如果有出现比int更高级则转换成更高级的，趋炎附势。其中，float类型虽然只有4个字节却要比long更高级，因为它能容纳小数。

float a=123.123f；为什么？因为定义变量还有一种方法

float a;

a=123.345;先定义再赋值，如果赋值行数离定义行太远，

那么a=123.345这种写法就会被误以为是double值了，所以

写成a=123.345F或者小写的f，我们可以一眼看出它是float值了。

byte--short--char--int--long--float--double

 

String字符串常用的提取方法&验证邮箱的格式是否符合规范

indexOf(a): a可以是字符串，字符，整型（ASICC码），返回的是第一次出现的位置，如果不存在a,则返回-1,返回的结果是int型

indexOf(a，int): int的作用是跳过前几个开始往后找下一个出现a的位置，返回的结果是int型

lastIndexOf(a):返回最后一次出现的位置，返回的结果是int型

lastIndexOf(a，int):返回最后一次出现的位置，所找的位置在从下标0开始到下标int结束的区间内，返回的结果是int型

endWith("str"):以str结尾，返回的结果是boolean型

startWith("str"):以str开始，返回的结果是boolean型

contains("str"):包含str，返回的结果是boolean型

trim():去掉字符串前后的空格，字符串中间的空格是不能去掉的，返回的结果是一个新的字符串String，不改变原来的字符串

split("a"):以a为分隔符分割字符串，返回一个String类型的数组

subString(a):截取a位置开始到最后的所有字符串，包括a

subString(a,b):截取a位置到b位置的字符串，包括a，不包括b

replace("str1"，”str2“):将原字符串中的所有的str1用str2代替，返回一个新的字符串，不改变原来的字符串

replaceFirst("str1"，”str2“):将原字符串中的第一次出现的str1用str2代替，返回一个新的字符串，不改变原来的字符串

indexOf(a): 

 

public static void ParseEmail(String line) { String regex = "\\w+@\\w+\\.(com\\.cn)|\\w+@\\w+\\.(com|cn)"; /* * \w代表[a-zA-z0-9_],之所以写成\\w是因为\有转义的意思，所以要输出 \必须得写成\\ + 代表可以有一次或者多次 * \\.就代表着.,因为.在正则表达式中代表一个任意的字符，所以要想写出.来就得要用到转义字符\ 要输出\就得要写成\\ * （）代表着一个组合，例如（com）会去匹配含有com的字符串，而com会去匹配含有c或者o或者m 的字符串 | 代表这或 * 注意：按照正则表达式去匹配的时候是有优先级的，从左至右，（）也可以看做是一 优先级的控制，\\w+@\\w+\\.(com|cn)+ * 改为\\w+@\\w+\\.com|cn+程序会以为\\w+@\\w+\\.com或者cn * 这样当对sadfsd@sdfsd.cn匹配时下面的程序会输出cn,而我们的初衷是让com与cn或 */ // String regex = "[a-zA-Z0-9_]+[@][a-zA-Z0-9]+([\\.com]|[\\.cn])"; Pattern pattern = Pattern.compile(regex); String context = "checkhere1@hotmail.com ;checkhere2@hotmail.com;sdfkfj@sfsdf65656.com.cn " + ";jfkdjgkjhgk@jdfjkg.cn.cn ;sadfsd@sdfsd.cn"; Matcher matcher = pattern.matcher(context); while (matcher.find()) { System.out.println(matcher.group()); } }

^[^\/][\d\w] \b@[a-zA-ZA-z0-9] \.[a-z] /g

var regex2 = /[\d\w] \b@[a-zA-ZA-z0-9] \.[a-z] /g;

console.log(string.match(regex2))

++i 与 i++，++i是先自增再赋值。

2.运算符

在java当中，使用运算符+、-、*、/ 表示加减乘除，当参与 / 运算的两个操作数都是整数的时候，表示整数除法；否则表示浮点数。整数的求余操作用 % 表示。、

计算下面的值是多少？

2.数值之间的转化

在程序运行的时候，我们经常需要将一种数值类型转化为另一种数值类型。下图给出了数值类型之间的合法转化。

浮点类型不能精确运算，运算要使用BigDecimal类

3.强制类型转换

在上面我们可以看到，在必要的时候，int类型的值将会自动的转化为double类型。但另一方面，有时候也需要将double转化为int.。在java当中允许这种数值之间的类型转化。当然也会有以一些数据丢失。在这样情况之下，需要通过强制类型转换实现这个操作，强制类型的语法格式是通过（）当中给出的想要转化的目标类型。

        BigDecimal big1 = new BigDecimal(Float.toString(1.2f));
        BigDecimal big2 = new BigDecimal(Float.toString(1));

        float r1 = big1.subtract(big2).floatValue();

4.结合赋值和运算符

可以在赋值当中使用二元运算，这是一种很简单的简写形式。

5.自增和自减运算符

public static void main(String[] args) {
		int m = 10;
		int n = 10;
		int a = ++m;
		int b = n++;
		System.out.println(a);
		System.out.println(b);
}

 

6.关系和boolean运算符

①：检测相等性： ==

②：检测不等：！=

③：最后，还有经常使用的<、>(、<=和>=

比较两个基础数据类型，返回值为true或者flase

④：java使用&&表示逻辑”与“运算符，使用||表示”或“运算符,

⑤：三目运算符：condition?expression1:expression2

System.out.println(10<9?1:2);

3.位运算

处理数据类型的时候，可以直接对组成整形数值的各个位完成操作

&("and") |("or") ~（"not"） ^("xor”)

以下用例皆为byte类型：

①：按位与操作

两个操作数，如果同为1则为1，否则为0

 

②：按位或操作

只有两个操作数对应位同为0时，结果为0，其余全为1.

 

③：~:按位取反

 

④：按位亦或操作

两个操作数对应位，相同则结果为0，不同则结果为1

 

2.移位运算

以下用例皆为byte类型：

①：左移(<<)

右边空出来的位用0填补高位左移溢出则舍弃该高位

左移几位其实就是这个数 *2 的几次幂

 

②：右移(>>)

左边空出来的位用0或1填补，正数用0负数用1填补。

右移几位其实就是这个数/2的几次幂 -----》除法

 

③：无符号右移(>>>)

数据进行右移时，高位出现的空位，无论原高位是什么，空位都用0补

总结：左移右移其实操作的都是2的倍数

重点面试题：

用最快速度计算出2*16的值

	public static void main(String[] args) {
		//用最快的速度计算出2*8
		long startTime=System.nanoTime();   //获取开始时间  
		System.out.println(2*16);
		long endTime=System.nanoTime(); //获取结束时间  
		System.out.println("程序运行时间： "+(endTime-startTime)+"ns");   
		
		long startTime1=System.nanoTime();   //获取开始时间  
		System.out.println(2<<4);
		long endTime1=System.nanoTime(); //获取结束时间  
		System.out.println("程序运行时间： "+(endTime1-startTime1)+"ns");   
	}

if(string == null || string.length() <= 0)

String字符串在我们的学习当中是最经常使用到的，要想搞清楚java字符串，我们就要弄清楚字符串常量池的概念

4.字符串常量池

一、字符串常量池

（本次讲解以jdk1.8为例）

jdk 6.0 字符串常量池在方法区，方法区的具体体现可以看做是堆中的永久区。

jdk 7.0 java 虚拟机规范中不再声明方法区，字符串常量池存放在堆空间中

jdk 8.0 java 虚拟机规范中又声明了元空间，字符串常量池存放在元空间中

关于永久代和元空间的讲解

https://www.cnblogs.com/paddix/p/5309550.html

元空间的本质和永久代类似，都是对JVM规范中方法区的实现。不过元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。

--------------------------------------------------------------------------------------------

 

(1).字符串常量池的概念

1.

字符串常量池是java的一项技术，从字面意思理解就是把经常用到的数据存放到某一内存当中，避免频繁的数据创建和销毁，实现数据的共享，提高系统性能。可以看一下代码：

 

这里判断的是地址是否相等。

我们来看一下我们的内存到底干了什么？

虚拟机首先字符串常量池中查找该字符串是否已经存在，如果存在则返回该引用，如果不存在则会在字符串常量池当中创建该字符串对象，然后到字符串常量池当中去注册该字符串。

二.字符串拼接

 

F:\>javap -c Test.class
Compiled from "Test.java"
public class innter.Test {
  public innter.Test();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String 123
       2: astore_1
       3: ldc           #3                  // String 456
       5: astore_2
       6: ldc           #4                  // String 123456
       8: astore_3
       9: new           #5                  // class java/lang/StringBuilder
      12: dup
      13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
      16: aload_1
      17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      20: aload_2
      21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      27: astore        4
      29: getstatic     #9                  // Field java/lang/System.out:Ljava/io/PrintStream;
      32: aload         4
      34: aload_3
      35: if_acmpne     42
      38: iconst_1
      39: goto          43
      42: iconst_0
      43: invokevirtual #10                 // Method java/io/PrintStream.println:(Z)V
      46: return
}

 

我们可以看到，这里调用了StringBulider的两个方法append和toString方法。使用append进行拼接，拼接字符串后，虚拟机调用StringBuilder的toString()方法获取字符串的“123456”，然后该值存放至s4,那么这个拼接好的“123456”到底是以什么形式传递给s4的呢，我们来看toString方法。

 

这里直接创建了一个新的。

这里之所以为true，是因为jvm编译阶段过编译器优化后会把字符串常量直接合并成"123456"，在java当中，String提供的方法，一般都是重新new一个对象。

三.String、StringBuffer和StringBuilder的区别与联系

 

 

1.我们为什么不使用String类型

String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，然后将指针指向新的 String 对象，这样不仅效率低下，而且大量浪费有限的内存空间，所以经常改变内容的字符串最好不要用 String 。因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，那速度是一定会相当慢的。

 

我们可以看到，初始String值为“hello”，然后在这个字符串后面加上新的字符串“world”，这个过程是需要重新在栈堆内存中开辟内存空间的，最终得到了“hello world”字符串也相应的需要开辟内存空间，这样短短的两个字符串，却需要开辟三次内存空间，不得不说这是对内存空间的极大浪费。为了应对经常性的字符串相关的操作，就需要使用Java提供的其他两个操作字符串的类——StringBuffer类和StringBuild类来对此种变化字符串进行处理。

2.StringBuffer 和 StringBuilder 类

StringBuffer 字符串变量（线程安全）

StringBuilder 字符串变量（非线程安全）

当对字符串进行修改的时候，特别是字符串对象经常改变的情况下，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

1.字串

String.substring(,)可以产生一个新的串。

 

2.空串和Null串

空串“”是长度为0的字符串，可以用以下的代码来检测是否为空：

if(str.length()==0) 或 if(str.equals(""))

if(str == null)

有时候要检验一个字符串既不是null也不是空串，这种情况下需要使用

if( str != null && str.length() != 0))

 

if(str == null || string.length() <= 0)

3.==和equals的区别

引用数据类型和基本数据类型的区别

1.基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean 

  他们之间的比较，应用双等号（==）,比较的是他们的值。

2.引用数据类型：当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。例如，string类的equals方法

 

1.首先比较的是两个字符串的地址是否相同，如果相同返回true.

2.如果字符串地址不相同，那么首先会判断两者是否属于同一种数据类型，如果是，然后在比较里边的内容是否相同。

1.读取输入

Scanner in = new Scanner(System.in);

String name = in.next()；

从键盘换行输入的情况

Scanner inlength = new Scanner(System.in);
        int length = inlength.nextInt();
        int[] arr = new int[length];

        for (int i = 0; i < arr.length; i++) {
            Scanner inScanner = new Scanner(System.in);
            arr[i] = inScanner.nextInt();
        }
        System.out.println(Arrays.toString(arr));

从键盘用空格分隔输入的情况1

  Scanner inlength = new Scanner(System.in);
        System.out.println("你想输入多少个数组");
        int length = inlength.nextInt();
        String[] arr = new String[length];
        Scanner inScanner = new Scanner(System.in);
        for (int i = 0; i < arr.length; i++) {
            System.out.println("第"+i+"个,请输入:");
            arr[i] = inScanner.next();
        }
        System.out.println(Arrays.toString(arr));

从键盘用空格分隔输入的情况2

        String s =in.nextLine();
        String[] str =s.split(" ");

        for(String data : str)
        System.out.print(data+" ");
        System.out.println(str.toString());