java基础巩固
1.Java中lenth、lenth()和size()的区别是什么？
lenth,lenth(),size()的区别
lenth是数组的专属属性
lenth的英语是长度，是二维的，字符串的长度用lenth();
size的英语是尺寸是三维的 ，容器大小，泛型 用三维
常见容器有List/Set/Map
String str = “”;
System.out.print(str.split(“,”).length);
答案： 1
public static void main(String[] args) {
System.out.println("------------------str-------------------");
String str = "";
System.out.println(str.split(",").length);//1
System.out.println("hutool:" + StrUtil.split(str, ",").size());//1
System.out.println("");
System.out.println("------------------str2-------------------");
String str2 = ",";
System.out.println(str2.split(",").length);//0 list本身内容["",""] list倒序遍历如果内容的length=0【""的length当然是0】 那么长度-1
System.out.println("hutool:" + StrUtil.split(str2, ",").size());//2
System.out.println("------------------str3-------------------");
String str3 = ",,1";
System.out.println(str3.split(",").length);//3 list本身内容["","","1"] list倒序遍历发现1的length不为0 终止长度-1操作 总长度3
System.out.println("hutool:" + StrUtil.split(str3, ",").size());//3
System.out.println("------------------str4-------------------");
String str4 = ",1,";
System.out.println(str4.split(",").length);//2 list本身内容["","1",""] list倒序遍历 第一次发现"".length=0长度-1 再次遍历第二个元素1的length不为0 终止长度-1操作 总长度2
System.out.println("hutool:" + StrUtil.split(str4, ",").size());//3
}
public static void main(String[] args) {
//当limit<0的时候，数组可以包含任意长度的字符串，不删除最后一个空字符，最后一个,后没有空格（连空格都没有）就是空[],有空格就是[ ] 和limit是多少没有关系
System.out.println("-----------------------负数----------------------------");
String s = "小bean哥,是,帅哥,";
String[] res = s.split(",",-2);
int i = 1;
for (String ss:res) {
System.out.println("第"+i+"个字符串为["+ss+"]");
i++;
}
System.out.println("字符串共有："+res.length+"个"); //不管有没有空格都是4个
//当limit为0 (默认值)的时候，会自动清空最后一个空值！！！很重要！！
System.out.println("-----------------------0----------------------------");
String s1 = "小bean哥,是,帅哥,";
String[] res1 = s1.split(",",0);
int j = 1;
for (String ss:res1) {
System.out.println("第"+j+"个字符串为["+ss+"]");
j++;
}
System.out.println("字符串共有："+res1.length+"个"); //最后一个,后没有空格就是3个，有就是四个
System.out.println("-----------------------正数----------------------------");
String s2 = "小bean哥,是,帅哥,";
String[] res2 = s2.split(",",2);
int k = 1;
for (String ss:res2) {
System.out.println("第"+k+"个字符串为["+ss+"]");
k++;
}
//正数 limit 和分隔符 一样 就是 limit个 ，limit 大 就是分隔符加1，limit小就是limit 不超过limit +1
System.out.println("字符串共有："+res2.length+"个");
System.out.println("-----------------------------默认值-------------------------------------");
String s3 = "小bean哥,是,帅哥,";
String[] res3 = s3.split(","); // 没有就是默认，和传0一样
int q = 1;
for (String ss:res3) {
System.out.println("第"+q+"个字符串为["+ss+"]");
q++;
}
System.out.println("字符串共有："+res3.length+"个");
}
2.输出的结果
public class Father {
private int i=test();
private static int j=method();
static {
System.out.print("<1>");
}
Father(){
System.out.print("<2>");
}
{
System.out.print("<3>");
}
public int test(){
System.out.print("<4>");
return 1;
}
public static int method(){
System.out.print("<5>");
return 1;
}
public class Son extends Father{
private int i=test();
private static int j=method();
static {
System.out.print("<6>");
}
Son(){
System.out.print("<7>");
}
{
System.out.print("<8>");
}
@Override
public int test(){
System.out.print("<9>");
return 1;
}
public static int method(){
System.out.print("<10>");
return 1;
}
public static void main(String[] args) {
Son s1=new Son();
System.out.println("****************");
Son s2=new Son();
}
}
结果是：<5><1><10><6><9><3><2><9><8><7>****************
<9><3><2><9><8><7>
原因：先初始化父类后初始化子类
初始化静态变量赋值和静态代码块 从上到下
5,1，10，6在new之前就初始化这四个
不是4而是9因为非静态方法前有个默认对象的this，this表示正在创建的对象，所以test执行子类重写代码
2.语法规范
3.数据类型
基本数据类型
整数型：short（2 ) , byte(1) , int(4) ,long(8)
浮点型： float(4) ,double(8)
字符型： char(2个字节)
布尔型：boolean(1位)
引用类型
数组，对象，接口
4.表达式
类型的自动提升，有double就是double,有float就是float
强制转换
int k1=2;
float k2=1.2f;
double k3=0.04;
System.out.println(k1 * k2);//2.4
System.out.println((int) (k1*k3));//0 把整个转化为int类型
System.out.println((int) (k1)*k3);//0.08 把k1转化为int类型
5.运算符
算数运算符 +，- ，（乘），/（除），%（取余）
关系运算符
常见错误5<x<10; 更正x>5 && x<10
逻辑运算符 &&，&，！，||，|
注意：&&，|| 短路，即左边不成立就不用看右边
位运算符&，| ，<<(左移一位相当于乘以2，左移2位相当于乘以2个2) ，>>(右移相当于除以2）
eg:38怎么算最快，把3左移三位，位运算是cpu直接支持的很快
循环
集合和遍历
list和set和map的区别：
1、List、Set都是继承自Collection接口，Map则不是
List线程不安全解决方案：
在写入的时候避免发生覆盖，造成数据问题！ 读写分离
CopyOnWriteArrayList 比 Vector NB在哪里？（底层没有用synchronized，而是用的lock）
1、List<String> list = new Vector<>();
2、List<String> list = Collections.synchronizedList(new ArrayList<>());
3、List<String> list = new CopyOnWriteArrayList<>();
set线程不安全解决方案：
1. Set<String> set = Collections.synchronizedSet(new HashSet<>());
2.Set<String> set = new CopyOnWriteArraySet<>();
map程不安全解决方案：
1. Map<String, String> map = Collections.synchronizedMap(new HashMap<>());
2. Map<String, String> map = new ConcurrentHashMap<>();
2、List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复，重复元素会覆盖掉，（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）
3、Set和List对比：
Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。
List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。
4、Map适合储存键值对的数据
总结： List中的元素，有序、可重复、可为空；
Set中的元素，无序、不重复、只有一个空元素；
Map中的元素，无序、键不重，值可重、可一个空键、多可空值；
5、线程安全集合类与非线程安全集合类 :
LinkedList、ArrayList、HashSet是非线程安全的，Vector是线程安全的;
HashMap是非线程安全的，HashTable是线程安全的;
StringBuilder是非线程安全的，StringBuffer是线程安全的。
-----助记：builder是建筑物的意思 建筑物不安全 线程不安全
package com.caopei.base;
import java.util.*;
public class Connection {
public static void main(String[] args) {
List arr = new ArrayList();
arr.add("a");
arr.add("1");
arr.add("ff");
for (int i = 0; i < arr.size(); i++) {
System.out.println(arr.get(i));
}
Iterator iterator = arr.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
for(Object a:arr){
System.out.println(a);
}
HashSet<String> set = new HashSet<>();
set.add("aaa");
set.add("bbbb");
set.add("ccc");
set.addAll(arr);
System.out.println("下满是set");
// for (int i = 0; i <set. ; i++) set没有顺序所以不能
// 按这个遍历
for(String s:set){
//System.out.println(s.toString());
System.out.println(s);
}
Iterator<String> st = set.iterator();
while (st.hasNext()){
System.out.println(st.next());
}
System.out.println("以下是map的遍历");
Map<Integer,String> map = new HashMap();
map.put(1,"dddd");
map.put(2,"hhhh");
map.put(3,"hh");
//用增强for遍历，keyset()返回的是所有map里面的key，
//又叫foreach迭代键值对
for(Object key:map.keySet()){
System.out.println("key"+key+"value"+map.get(key));
}
//使用foreach循环遍历,entryset();
for(Map.Entry<Integer,String> en:map.entrySet()){
System.out.println(en.getKey() + "\t" + en.getValue());
}
//使用迭代器遍历
Iterator<Map.Entry<Integer, String>> ite = map.entrySet().iterator();
while (ite.hasNext()){
Map.Entry<Integer, String> e = ite.next();
System.out.println(e.getKey() + "\t" + e.getValue());
}
//使用lambda,左边是参数，右边是值
map.forEach((k,v)-> System.out.println("k"+k+"\tv"+v));
}
}
new 就是实例化，实例化是实例化对象，接口不能实例化 所以只能
new Arrarylist();-------ArraryList是类
而List是接口
lambda表达式
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）
lambda 表达式的语法格式如下：
(parameters) -> expression
或
(parameters) ->{ statements; }
HashMap 与 Hashtable 的区别
1） 历史原因: Hashtable继承Dictonary类, HashMap继承自abstractMap
2） HashMap允许空的键值对, 但最多只有一个空对象，而HashTable不允许。
3） HashTable同步，而HashMap非同步，效率上比HashTable要高
JDK 和 JRE 有什么区别？
JDK：Java Development Kit 的简称，Java 开发工具包，提供了 Java 的开发环境和运行环境。
JRE：Java Runtime Environment 的简称，，为 Java 的运行提供了所需环境。具体来说 JDK 其实包含了 JRE，同时还包含了编译 Java 源码的编译器 Javac和Java 程序调试和分析的工具。简单来说：如果你需要运行 Java 程序，只需安装 JRE 就可以
了，如果你需要编写 Java 程序，需要安装 JDK
package com.caopei.base;
import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
import java.util.Iterator;
import java.util.Scanner;
//条件
public class Cycli {
static Scanner scanner = new Scanner(System.in);
public static void main(String[] args) {
//打印倒三角形,Scanner扫描仪，可以向用户获取
System.out.println("请输入您想要输入的数字/季节");
int input=scanner.nextInt();
for (int i = 0; i <input ; i++) {
for (int j = input; j >i; j--) {
System.out.print("*");
}
System.out.println( );
}
//给定月份输出季节
switch(input){
case 3:
case 4:
case 5:
System.out.println("春季");
break; //最好在每一个后面加break,不然获取到了 程序也会继续向下执行
case 8:
case 7:
case 6:
System.out.println("夏季");
break;
default:
System.out.println("该季节不存在哟");
break;
}
}
}
==和equals的区别
等等基本数据类型比较的是值，引用类型比较的是内存地址
equals本质就是==，只不过 String 和 Integer 等重写了 equals 方法，把它变成了值比较。所以一般情况下 equals 比较的是值是否相等
Cat c1 = new Cat(“王磊”);
Cat c2 = new Cat(“王磊”);
//对象类型没有重写equals方法
System.out.println(c1.equals(c2)); // false
String s1 = new String(“老王”);
String s2 = new String(“老王”);
//String重写了equals方法
System.out.println(s1.equals(s2)); // true
public class Test2 {
public static void main(String[] args) {
String s1 = "springboot";
String s2 = "spring";
String s3 = "boot";
// 常量与常量的拼接结果存放在常量池
String s4 = "spring" + "boot";
// 拼接的时候，只要其中有一个是变量，结果就在堆中，此刻a3为变量
String s5 = "spring" + s3;
String s6 = s2 + s3;
// new String()创建的字符串保存在堆内存
String s7 = new String("springboot");
// 如果拼接的结果调用intern()方法，返回值就在常量池中
String s8 = s6.intern();
System.out.println(s1 == s4); // true
System.out.println(s1 == s5); // false
System.out.println(s1 == s6); // false
System.out.println(s1 == s7); // false
System.out.println(s1 == s8); // true
}
}
两个对象的 hashCode() 相同，则 equals() 也一定为 true，对吗？
不对，因为在散列表中，hashCode() 相等即两个键值对的哈希值相等，并不一定能得出键值对相等。
final 在 Java 中有什么作用？
final 修饰的类叫最终类，该类不能被继承。
final 修饰的方法不能被重写。
final 修饰的变量叫常量，常量必须初始化，初始化之后值就不能被修改。
面向对象编程三大特性------封装、继承、多态
封装：
封装的是自己的属性和方法，隐藏细节
封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果不想被外界方法，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。
继承：
继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类
1、子类拥有父类非private的属性和方法。
2、子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
3、子类可以用自己的方式实现父类的方法。（以后介绍）。
多态：
对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同
Java实现多态有三个必要条件：继承、重写、向上转型
String和StringBuffer、StringBuilder的区别是什么？
对于三者使用的总结：
如果要操作少量的数据用 = String
单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
（线程安全）
自动装箱与拆箱
装箱：将基本类型用它们对应的引用类型包装起来；
拆箱：将包装类型转换为基本数据类型；
接口和抽象类的区别是什么？
1.接口的方法默认是public，所有方法在接口中不能有实现，抽象类可以有非抽象的方法
2.接口中的实例变量默认是final类型的，而抽象类中则不一定
3.一个类可以实现多个接口，但最多只能实现一个抽象类
4.一个类实现接口的话要实现接口的所有方法，而抽象类不一定
5.接口不能用new实例化，但可以声明，但是必须引用一个实现该接口的对象
从设计层面来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为的规范。
String str="i"与 String str=new String(“i”)一样吗？
不一样，因为内存的分配方式不一样。String str="i"的方式，Java 虚拟机会将其分配到常量池中；而
String str=new String(“i”) 则会被分到堆内存中。
BIO、NIO、AIO 有什么区别？
BIO：Block IO 同步阻塞式 IO，就是我们平常使用的传统 IO，它的特点是模式简单使用方便，并发处理能力低。
NIO：Non IO 同步非阻塞 IO，是传统 IO 的升级，客户端和服务器端通过 Channel（通道）通讯，实现了多路复用。
AIO：Asynchronous IO 是 NIO 的升级，也叫 NIO2，实现了异步非堵塞 IO ，异步 IO 的操作基于事件和回调机制。
常见笔试题
1.jvm
public static void main(String[] args) {
int i = 1; //i=4
i =i++;
int j = i++; //j=1;
int k = i + ++i *i++; //k=11
System.out.println("i=" +i + "\tj=" +j+ "\tk="+k);
}
过程如下
小结:
2.单例模式
单：单个
例：实例
即：某个类在整个系统中只能有一个实例对象可被获取和使用
类初始化顺序
package com.cp.mp.day01;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import java.io.Serializable;
@Data
@Builder
@AllArgsConstructor
public class A implements Serializable {
private Integer a1;
private int a2;
private float a3;
private Float a5;
private double a4;
private Double a6;
private long a7;
private Long a8;
private String a9;
/**
* @创建人 caopei
* @创建时间 2021/2/18
* @description:
* 顺序：静态代码块，非静态代码块，无参用this先调用有参再调用无参
*
*/
public A() {
this("caopei");
System.out.println("我是无参构造函数");
}//第三步
public A(String name) {
System.out.println("我是有参构造函数"+name);
}
//初始化的时候就有
static {
System.out.println("我是静态代码块2");//第一步
}
static {
System.out.println("我是静态代码块");//第一步
}
//(new的时候就有,new一下有一次)
{
System.out.println("我是非静态代码块2");//第二部
}
{
System.out.println("我是非静态代码块");//第二部
}
public static void main(String[] args) {
A a = new A();
System.out.println(a.a1);
System.out.println(a.a2);
System.out.println(a.a3);
System.out.println(a.a4);
System.out.println(a.a5);
System.out.println(a.a6);
System.out.println(a.a7);
System.out.println(a.a8);
A a2 = A.builder().a1(1).a2(2).a9("12").build(); //遍历设置（也包含new）
System.out.println(a2);
/*
结果：
我是非静态代码块2 相当于new
我是非静态代码块
遍历
A(a1=1, a2=2, a3=0.0, a5=null, a4=0.0, a6=null, a7=0, a8=null, a9=12)
*/
}
}
148
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
