java基础

JDK、JRE、JVM联系

1.三者关系解释：
JDK的安装目录下有个jre目录，jre目录下有lib和bin文件夹，bin文件夹下有jvm，lib里面包含jvm运行需要的类库。

2.名词解释：
jdk=java developent kit=java运行工具包
jre=Java Runtime Enviroment=java运行环境
jvm=Java virtual machine=java虚拟机

3.java语言为什么跨平台？
因为java程序会先生成字节码文件（.class）调用jre中的lib里面的类库并在jvm中执行，且屏蔽了一切关于操作系统的平台的相关信息。

4.java编译过程：
helloworld.java->编译(javac)->helloworld.class->运行(java)->helloworld.java

java基本数据类型**

四类：整形、浮点型、字符型、布尔型
八种:byte、short、int、long；double、float；char；boolea；
默认值分别对应：0，0，0，0L;0.0f,0.0d;null;false

自动类型装换
精度低的类型可以转为高精度的类型，但是高精度向低精度转换会丢失精度。
ps：boolean类型不参与转换

例：

byte b = 1；
int i = byte b；//把byte类型的变量b转为int类型

强制类型转换
例：

int i = 1；
byte b = (byte) i;//将int类型的i变量强转为byte类型，此种方法会丢失精度

（int）20.1==20；
（int）-20.01f==-20；//浮点型到整型的是舍弃小数点得到的，不是四舍五入

常量：

字面值常量：

• 整数常量
• 小数常量
• 字符常量
• 字符串常量
• 布尔常量
• null常量

自定义常量：
final int x = 10;表示x记录的值不能改变。
x就是我们自定义的常量，称之为自定义常量。还有如：math类中的PI，和MAX_VLAUE;

数据类型：

1.基本数据类型->
四类：整型、字符型、浮点型、布尔型 ；
八种：byte、short、int、long、char、floa、double、boolea
2.引用数据类型->
三类：数组、类、接口

变量：

根据作用的不同范围划分：
1.局部变量：->1.方法体中的变量 2.形参 3.代码块中的变量 注意：存放在栈内存中，随方法的执行而消失
2.成员变量：->1.静态变量 2.实例变量 注意：存放在堆内存中
根据引用的不同数据类型划分：
1.基本数据类型引用变量
2.引用数据类型引用变量

成员变量和局部变量的区别

从语法形式上看:
成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。
从变量在内存中的存储方式来看:
如果成员变量是使用static修饰的，那么这个成员变量是属于类的，如果没有使用static修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
从变量在内存中的生存时间上看:
成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。
成员变量如果没有被赋初值:
则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

参数形式：

**1.形参：**定义方法时参数列表中的参数，无初始化值
**2.实参：**传递给形参的参数，有具体的值

方法参数的传递:

1.当传递的是基本数据类型,形参的改变只限制于形参所在的方法里的局部变量,当修改完成后,方法和形参就一同消失在栈内存中,不会影响其他方法里面的参数改变
2.当传递的是引用数据类型,修改引用变量会改变堆内存中的实际参数,所以修改引用变量会改变所有引用变量引用的值.

For循环

for循环每个部分执行的次数，以循环N次为例；
1.只会执行1次
2.至少会执行一次，在第一次就判断为false跳出循环时，最多执行N+1次
3.最少执行0次，最多执行N次
4.最少执行0次，最多执行N次
for(1.初始化语句;2.条件判断语句;4.条件控制语句 ){
3.循环体语句
}

方法的重写和重载：

**重写：**除方法体外都要相同，重写发生在子类继承父类中，是不同的类
**重载：**参数列表不同：参数类型，数目，顺序不同即能构成重载，但是不能用返回值类型定义是否方法重载，重载发生在同一个类中，是java多态性的体现。[发生在一个类中,方法名相同,参数列表不一样,三要素]
注意：参数列表不一样只能针对形参是不同数据类型的,如果形参数据类型一样则不存在顺序不一样

this关键字&static关键字:

this是当前类的对象的引用,总是代表当前对象
.可以用this调用成员变量和成员方法
不能用this调用static修饰的方法和属性,static修饰的属性和方法从属于类,而this从属于对象。
.
this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

• 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
• 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

static是一种标志,用于区分成员变量,方法,代码块,内部类.static修饰的方法里面不能访问实例变量和方法(从属于类,假设类还没有创建实例,那么是怎么能访问实例属性呢?),
但是反过来相反,对象随意访问类的属性.
注意：
1.不能把方法体中的局部变量声明成静态变量
2.静态方法中不能直接调用非静态方法，而非静态方法可以直接调用静态方法

==和equals的区别

==可以比较基本数据类型和引用数据类型而equals只能比较引用数据类型 。==在比较基本数据类型时比较的是内容，在比较引用数据类型时比较的时引用地址值。而equals比较的只能时引用数据类型的地址值。但是像String这样的类因为重写了equals和hashcode方法，所以使用equals时比较引用数据类型时比较的时引用类型所引用的内容是否相等！

private

private既可以修饰成员变量也可以修饰成员方法还可以修饰内部类，但是不能修饰局部变量和方法。

String和Stringbuffer、StringBuilderS

String类的特点：
1.一旦定义了长度和内容就不变了
2.虽然长度不可变但是String的值（对象）却是可以被共享
3.字符串从jdk9开始就不再由char[]数组组成而是换成占用内存更小的byte[ ]字节数组组成

string类的检查机制：
String类有俩种定义格式：
1.通过构造方法

String s = new String("abc");

2.直接赋值调用

String s = "abc";

需要强调的是：如果用直接赋值生成的String对象如果内容相同则不会生成新的String对象 ，而是存在常量池中（堆内存中 jdk8后），如果要用都从常量池中调用，而不会生成新的String对象

String类的常用方法：
公例:String s = “abc”

1.获取字符串长度
s.length();
2.获取字符串某一位置的字符
s.charAt(int index); charAt(0到s.length-1);
返回：指定索引的对应字符
3.获取字符床中字符所对应的索引
s.indexof(“a”);——>0
s.lastindexof(“c”)；——>2
4.字符串的比较

public int compareTo(String str)
//该方法是对字符串内容按字典顺序进行大小比较，
//通过返回的整数值指明当前字符串与参数字符串的大小关系。
//若当前对象比参数大则返回正整数，反之返回负整数，相等返回0。

public int compareToIgnoreCase (String str)
//与compareTo方法相似，但忽略大小写。

public boolean equals(Object obj)
//比较当前字符串和参数字符串，在两个字符串
相等的时候返回true，否则返回false。

public boolean equalsIgnoreCase(String str)

5.字符串大小写转换
s.tolowercase();
s.tohighercase();

6.字符串的截取

String s = "abca";
sout(s.substring(1));//输出：bca（从Index=1处开始截取到最后）
sout(s.substring(1,2))//输出：b(包头不包尾)

7.字符串的替换

String s = "abc";
String s1 = s.replace("a","b");//输出：bbc

8.字符串的反转

//反转
private static String reverseString1(String s1) {
        String s = "";
        //倒序加到新的字符串上
        for (int i = s1.length()-1; i >=0 ; i--) {
            s+=s1.charAt(i);
        }
        return s;
    }

9.字符串转字符数组

String  s = "abc";
char[] c = s.toCharArray();
//字符数组转字符串
char[] c = {'a','b','c'};
String s = "";
c.length().fori{
s+=char[i];
}
sout(s);

StringBuilder

概念：字符串长度和内容可变的数组，底层实际是数组实现的，数组的扩容生成新的数组。
定义：
1.通过无参构造方法生成

StringBuilder sb = new StringBuilder();
sb.append("abc");

2.通过带参构造方法生成

StringBuilder sb = new StringBuilder("abc");

StringBuilder的常用方法：
1.append-增

sb.append("abc");

2.reverse-反转

String s = "abc";
sb.reverse(s);

3.StringBuilder和String之间的相互转换
sb 转 s:
1.sb.toString();
2.sb+’"";
s 转 sb
StringBuilder sb = new StringBuilder(s);

为什么需要StringBuilder和String之间要相互转换？
1.为什么string要转为sb？
a.String对象每拼接一次就会产生一个新的String对象，堆内存开销大
b.为了使用StringBuilder里面的方法，比较好用。如reverse、append方法等
2.为什么sb要转String?
因为String对象变为StringBuilder进行操作后，如果程序里需要的还是StringBuilder那么就还需要把String变回去。

ArrayList

概念：ArrayList是Java集合框架中的一个重要的类，它继承于AbstractList，实现了List接口，是一个长度可变的集合，提供了增删改查的功能。集合中允许null的存在。ArrayList类还是实现了RandomAccess接口，可以对元素进行快速访问。实现了Serializable接口，说明ArrayList可以被序列化，还有Cloneable接口，可以被复制。和Vector不同的是，ArrayList不是线程安全的。
注意：ArrayList中只能存放引用数据类型，不可以放入基本数据类型。

java.util.ArrayList < E > 的一些方法	描述
+ArrayList()	构造函数，创建一个空的列表, size为0
+add(o: E): void	在list的末尾添加一个元素o
+add(index: int, o: E): void	在指定的index处插入元素o
+get(index: int): E	返回指定index处的元素
+indexOf(o: Object): int	返回list中第一个匹配元素的index
+isEmpty(): boolean	如果list不含元素，返回true
+lastIndexOf(o: Object): int	返回list中最后一个匹配元素的index
+remove(index: int): boolean	删除指定index处的元素，如果元素被删除，返回true
+size(): int	返回list中元素个数
+set(index: int, o: E): E	设置指定index处的元素为o
+contains(o: Object): boolean	如果list含有元素o，返回true

数组和ArrayList的比较

操作	数组	ArrayList
创建 array/ArrayList	String[] arr = new String[10]	ArrayList<> arr = new ArrayList<>();
访问一个元素	arr[index]	arr.get(index);
更新一个元素	arr[index]=“element”	arr.set(index,element);
返回大小	arr.length	arr.size();
排序	java.util.Array.sort();	java.util.Collection.sort();
添加一个新元素	不可以	arr.add();
插入一个新元素	不可以	arr.add(index,element)
删除一个元素	不可以	arr.remove(index)or arr.remove(element);
删除所有元素	?	arr.clear();