Java笔记

huhuhuhuhuhu_hu

已于 2024-03-03 10:09:54 修改

阅读量781

点赞数 24

文章标签： java 笔记开发语言

于 2024-02-22 22:04:24 首次发布

本文链接：https://blog.csdn.net/huhuhuhuhuhu_hu/article/details/136239000

版权

idea快捷键

单行注释：ctrl+/
多行注释：ctrl + shift + /
调整格式：ctrl + alt + L
自动补全方法的返回值：ctrl + alt + V
自动生成方法：ctrl + alt + M(要引用住需要生成的方法代码
竖着选中：alt + 长按鼠标左键并移动
自动生成等号左边的变量（已输入表达式或方法）：alt + 回车
批量修改：shift + F6
查询方法：ctrl + N
指定方法查询：ctrl + B，跳转到选中的方法
将选中的内容自动生成循环结构：ctrl + alt + T、
查看方法的参数：ctrl + P

方法

方法是程序执行中最小的单元。（可理解为C、Matlab中的函数）可提高代码的复用性和可维护性。方法中包括成员变量和成员方法。
成员变量的完整定义格式：修饰符数据类型变量名称=初始化值
（一般无需指定初始化值）
方法重载：同类同名不同参。（返回值的类型相同，方法名相同，输入参数不同）
面向对象：命名建议：对象名的首字母大写、有意义，不能用关键字，满足标识符规定，驼峰式命名。
一个代码文件中可以定义多个类，但只能有一个类是public修饰的，且public修饰的类名必须是java代码文件的名称

关键字

1. private
修饰的成员变量或成员方法只能在类的内部访问，若需在外部访问私有成员变量，则需通过类内的方法来访问
2. this
本质谁所在方法调用者的地址
3. static

用法：static 数据类型变量名；
修饰的成员变量叫做静态变量，只能赋值一次，不能修改，且被该类的所有对象共享。
修饰的成员方法叫做静态方法，静态方法只能访问静态变量和静态方法。
非静态方法可以访问静态变量或静态方法，也可以访问非静态的成员变量和非静态的成员方法。
静态方法中没有this关键字。
静态随着类的加载而加载，优先于对象存在可以类名调用（推荐），也可以对象名调用；非静态随着对象的加载而加载。
静态区在堆内存中

4. final

修饰方法，表示该方法是最终方法，不能修改的方法；
修饰没有子类的类，表示最终类，不能被继承；
修饰常量（变量名字母大写，可用下划线），只能被赋值一次，不能修改，且必须赋值
修饰基本类型时，记录的值不能改变
修饰引用类型时，地址值不能改变，但属性值可以改变。

构造方法

定义类的时候，（虚拟机）默认调用构造方法。可以自己定义有参构造方法，不定义的话，自动生成默认的空参构造方法。无论是否使用，都手动书写无参构造方法和带全部参数的构造方法。调用构造方法的作用是进行初始化，而不是创造对象。

Java内存：

在这里插入图片描述

一个对象的内存：
Main 方法开始，main进入栈内存调用方法区里的main方法；调用类Student类：加载class文件（在方法区加载成员变量和成员方法的内容），申明局部变量，在堆内存开辟Student类需要的空间，存储的是类的地址，成员变量和成员方法的地址，默认初始化（生成成员变量的默认值），显式初始化（如果给定了局部变量的值就是显式初始化），成员变量的值在方法区，构造方法初始化，main中修改student成员变量的值或调用成员方法时，先访问student的地址，再找到属性修改，若成员变量为private不可直接修改时，用成员方法修改，即找到成员方法的地址并调用方法区的方法。调用方法后，进入栈内存执行，执行结束后释放栈内存的空间，然后堆内存的空间也释放。
第二次生成student对象时，class文件不需要再加载了
方法区的存储是临时存储
只要出现new关键字就会在堆内存开辟空间（创建数组、String时可以省略new不写，但也会在堆内存开辟空间（new出来的对象在堆内存

数据类型

基本数据类型

byte：占用1个字节，范围-2^7 ~ 2^7-1
、short、int、long、float、double、char和boolean

引用数据类型(对象类型)

需要通过构造来实例化（new），实际存储的是对象的引用（指针）

字符串

一、定义

定义格式：new(一般省略不写) String 变量名=“内容”

String str1 = "Hello";
//
String str2;
str2 = "Hello";
//
String str3 = new String("Hello");
String str4 = new String(str3);
//
char[] charArray = {'H','e','l','l','o'};
String str5 = new String(charArray);

字符串的内容是不能改变的，它的值在创建后不能被更改。字符串存储与串池内。
当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在，若不存在则创建新的字符串；若存在则复用。所以直接赋值可以节省内存（串池包含于堆内存，但串池和堆内存的地址要分开看）
new出来的不会复用，而是开辟新的空间。

二、方法

String str = "12345";
str.charAt(pos);//返回str的第pos个元素
str.substring("123");
str.replace("123","abc");//将123替换为abc
str.toCharArray();//转换为char数组
str.startwith('a');//判断是否以a开头
str.toLowerCase();//把字符串中的大写字母转换为小写

StringBulider

链式编程：在调用一个方法时，不需要用变量接收方法的结果，可以继续调用其他方法。

一、构造
StringBuilder 变量名=new 构造函数;
构造函数
StringBuilder() value内容为空，并设置容量为16个字节；
StringBuilder(CharSequece seq) 使用seq初始化，容量在此基础上加16；
StringBuilder(int capacity) 设置特定容量；
StringBuilder(String str) 使用str初始化，容量str大小的基础上加16；
二、方法

StringBulider sb = new StringBuilder();
sb.append("aaa").append("bbb").append("ccc");//在结尾添加字符串，链式编程
sb.length();//长度
sb.reverse();//反转
sb.toString();//转为字符串
sb.charAt(pos);//返回位置pos的元素
sb.delete(start,end);//删除从start到end的元素，包头不包尾
sb.deleteCharAt(pos);//删除第pos个元素

底层原理
- 字符串拼接时，如果没有变量参与，都是字符串直接相加，编译之后就是拼接之后的结果，会复用串池中的字符串；若有变量参与，则会创建新的字符串，浪费内存
- StringBuilder可提高效率，因为String拼接是将所有要拼接的内容都往StringBuilder中放，而直接用StringBuilder不会创建很多无用的空间，节省内存
- ==号，比较基本数据类型时，比较的是数据值；比较引用数据类型时，比较的是地址值。
- StringBuilder的长度：默认长度为16字节，若添加的内容长度小于16，直接存；添加的内容长度大于16会扩容（原来的容量*2+2）；若扩容之后还不够，以实际长度为准。

Integer

Integer类是基本类型int所对应的包装类，该类提供了多个方法，能在int类型和String类型之间相互转换，还提供了处理int类型时非常有用的其他一些常量和方法
一、构造

Integer i1 = 123;
Integer i2 = new Integer("123");

二、方法

String到int的转换

String str = "-100";
int num = Integer.parseInt(str);
//或
Integer i = new Integer(str);
int num1 = i.intValue();

转换为不同进制

int num = 6;
System.out.println("num的二进制：" + Integer.toBinaryString(num));
System.out.println("num的二进制：" + Integer.toString(num, 2));
System.out.println("num的八进制：" + Integer.toOctalString(num));
System.out.println("num的八进制：" + Integer.toString(num, 8));
System.out.println("num的十六进制：" + Integer.toHexString(num));
System.out.println("num的十六进制：" + Integer.toString(num, 16));

面向对象

三大特征：封装、继承、多态

1. 封装
对象代表什么，就要封装对应的数据并提供数据对应的行为。

2. 继承

一个父类可以有多个子类，一个子类只能有一个父类。

方法的重写

方法重写时，方法名前面加@Override；只有被添加到虚方法表的方法才能被重写。

重写方法的名称、形参列表必须和父类中的一致。
子类重写父类方法时，访问权限子类必须大于等于父类。（空着不写<protected<public）
子类重写父类方法时，返回值类型必须小于等于父类。
重写的方法尽量和父类保持一致。
私有（private）方法不能重写
子类不能重写父类的静态方法，会报错。

3. 多态
同类型的对象表现出的不同形态
因此，当一个方法的输入参数是一个类的时候，就可以传递这个类以及其所有的子类对象

表现形式：父类类型对象名 = 子类对象；
Fu f = new zi();
实现的前提：有继承关系；有父类引用指向子类对象；有方法重写。
多态调用成员的特点：
Fu f = new zi();
变量调用：编译看左边，运行也看左边
方法调用：编译看左边，运行看右边
即：变量调用：javac编译代码时，会检查父类中有没有该变量，有则编译成功，否则失败；java运行时，实际获取的就是坐标父类中成员变量的值。方法调用类似。
多态的弊端：不能调用子类的特有方法。
解决方法：强制转换
Fu f = new Zi();
Zi z = (Zi) f;
就可以用Zi中的特有方法了。
- 判断a是不是A类型（instanceof关键字）：
  转换类型时，可先判断a是否为类型A，若是，则转换为

Fu a = new A();//A是Fu的子类
if(a instanceof A b);//如果变量a是类A，则将a强转为类A，且变量名为b

包（package）

权限修饰符

public
表格

代码块

局部代码块：提前结束变量的生命周期（已淘汰
构造代码块：写在成员位置的代码块，创建对象时会先执行构造代码块再执行构造方法，每创建一次就执行一次（实际中很少用
静态代码块（重点）：格式：static{ }
随着类的加载而加载，自动触发、只执行一次

抽象类

抽象类：abstract
抽象方法：public abstract void func();
抽象类不能实例化，抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类；可以有构造方法（是为了创建子类对象）；抽象类的子类要么是重写抽象类的所有抽象方法，要么是抽象类

接口interface，implements

接口中成员的特点

成员变量只能是常量，默认修饰符：public static final
没有构造方法
成员方法只能是抽象方法，默认修饰符：public abstract

接口中的静态方法

定义：public static 返回值类型方法名（参数列表）{ 方法体 }
静态方法只能通过接口名调用，不能通过实现类名或对象名调用
public可省略，static不能
接口中的静态方法不能被重写。
JDK9新增的方法：接口的私有方法，普通的私有方法：用private修饰，给默认方法服务（default）；静态私有方法 private static 修饰，是给静态方法服务的

内部类

一个类的里面，再定义一个类

内部分的分类：成员内部类、静态内部类、局部内部类、匿名内部类。

成员内部类
写在成员位置的，属于外部类的成员。

获取成员内部类对象的方式：1. 当成员内部类被private修饰时，在外部类编写方法，对外提供内部类对象。2. 当成员内部类被非私有修饰时，直接创建对象。Outer.Inneer oi = new Outer().new Inner();
外部类成员变量和内部类成员变量重名时，在内部类的访问方法：Outer.this.变量名

静态内部类
静态内部类是成员内部类的一种

格式：
创建静态内部类对象：外部类名.内部类名对象名 = new 外部类名.内部类名();
调用静态方法：外部类名.内部类名.方法名（）；
静态内部类只能访问外部类中的静态变量和静态方法，若访问非静态的需要创建外部类的对象。

局部内部类
将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量。

外界无法直接使用局部内部类，需要在方法内部创建对象并使用。
局部内部类可以直接访问外部类的成员，也可以访问方法内的局部变量。

匿名内部类
用于只需要用一次的时候

API（Application Programming Interface,应用程序编程接口）

一些预先定义的函数

Math

正则表达式

在这里插入图片描述

只写一个’&‘就单纯表示’&'符号。
举例：

//电话号的正则表达式
String regex1 = "1[3-9]\\d{9}";//1开头，第二位只能是3-9，后9位可以是任意数字
\\邮箱的正则表达式
String regex2 = "\\w+@\\w+\\.\\w+";

用法：

String str = "Hello";
boolean b = str.matches("[(a-z)|(A-Z)]{5}");/判断str是否为5个字母组成字符串，大小写均可

方法的参数是接口时，调用这个方法的时候需要传递这个接口的实现类

Lambda表达式

Lambda表达式是JDK8开始后的一种新的语法形式

Lambda表达式可以用来简化匿名内部类的书写。
只能简化函数式接口的匿名内部类的写法。
函数式接口：有且仅有一个抽象方法的接口叫做函数式接口，接口上方可以加@FunctionalInterface注解。
Lambda的省略规则：
1. 参数类型可以省略
2. 如果只有一个参数，参数类型可省略，（）也可以省略
3. 如果Lambda表达式的方法体只有一行，大括号、分号、return可以（必须）同时省略。
  举例：

集合

在这里插入图片描述

List：添加元素是有序的、可重复、有索引
Set：添加元素是无序的、不重复、无索引

单列集合Collection

Collection是单列集合的顶层接口，所有方法被List和Set系列集合共享

常见成员方法：
add clear remove contains isEmpty size
三种通用的遍历方式
- 迭代器：在遍历的过程中需要删除元素时使用
- 增强for
- Lambda: 仅仅想遍历，使用后两种
Collection迭代器遍历：
1. 迭代器在遍历集合的时候不依赖索引
2. 迭代器需要掌握三个方法
3. 迭代器的四个细节：
  - 如果当前位置没有元素，还要强行获取，会报NoSuchElementException
  - 迭代器遍历完毕，指针不会复位
  - 循环中只能用一次next方法
  - 迭代器遍历时，不能用结合的方法进行增加或删除

List

List对象创建
List是一个接口，需要通过实现子类创建对象。List中存放的类型只能是Object及其子类，所以不能存放int, 应该为Integer

List<Integer> list1 = new ArrayList<>();//然后通过add()添加元素
List<Integer> list2 = new LinkedList<>();

List方法

//增删改查
add(Object data);//末尾增加data
add(Object data, pos);//在位置pos增加data
remove(int pos);//删除指定位置的元素
remove(Object);//删除指定元素
set(Object, pos);//修改指定位置的元素
forEach();//for循环遍历
iterator();//迭代器遍历

Set

无序、不重复、无索引
Set集合的方法基本上与Collection的API一致
Hash Set：无序、不重复、无索引
LinkedHashSet：有序、不重复、无索引
TreeSet：可排序、不重复、无索引

双列集合Map

一、Map是一个接口

特点
- 双列集合一次需要存一对数据，分别为键和值（例如商品和价格）
- 键不能重复，值可以重复
- 键和值是意义对应的，每个键只能找到自己对应的值
- 键+值这个整体称为”键值对“或”键值对对象“，Java中叫做”Entry对象“

方法

基本方法

Map<K, V> m = new HashMap();//K、V为键值的类型
//添加数据，若键已存在，会把原有的键值对覆盖，并返回被覆盖的值
//若键不存在，返回null
m.put(K key,V value);
//删除指定键值对并返回该值
m.remove(Object key);
//清空
void clear();
//
boolean containsKey(Object key);
//
boolean containsValue(Object Value);
//
boolean isEmpty();
//
int size();
//输出
System.out.println(m);

entrySet();
返回的是键值对对象

遍历

用keySet()方法获取所有键，返回的是Set集合，再通过get(key)方法获得key对应的值。(键找值)

//增强for遍历
	Set<K> keys = map.keySet();
	for(K key : keys){
		V value = map.get(key);
	}
	//Lambda表达式遍历
	keys.forEach(key -> System.out.println(key));
	//迭代器遍历
	Iterator<K> it = keys.iterator();
	while(it.hasNext()){
     	System.out.println(it.next());
 	}

entry对遍历

Set<Map.Entry<K,V>> entries = map.entrySet();
for(Map.Entry<K, V> entry : entries){
      K key = entry.getKey();
      V value = entry.getValue();
}
//
entries.forEach(entry -> System.out.println(entry));
//
Iterator<Map.Entry<K, V>> it2 = entries.iterator();
while(it2.hasNext()){
    System.out.println(it2.next());
}

map遍历（Lambda）
方法：default void forEach(Biconsumer<? super K，？ super V> action)

System.out.println("Map遍历：");
map.forEach(new BiConsumer<K, V>() {
    @Override
    public void accept(K key, V value) {
        System.out.println(key + "=" + value);
    }
});
System.out.println("Map遍历(+lambda表达式)：");
map.forEach(( key,  value) -> System.out.println(key + "=" + value));

二、HashMap

特点
1. HashMap是Map的一个实现类，没有额外需要学习的特有方法，直接用Map里的方法。
2. 特点都是由键决定的：无序、不重复、无索引
3. 和HashSet的底层原理一模一样，都是哈希表结构（数组加链表）

三、LinkedHashMap

特点：
1. 由键决定：有序、不重复、无索引，有序指的是保证存储和取出的元素顺序一致。
2. 原理：底层数据结构是哈希表，只是每个键值对元素又额外多了一个双链表的机制记录存储的顺序。

四、Hashtable
五、Properties
六、TreeMap

特点
1. 底层原理：红黑树（和TreeSet一样），所以增删改查性能较好
2. 由键决定：可排序、不重复、无索引
3. 默认按照键的顺序，从小到大排序，也可以按自己规定的规则排序
  代码书写两种排序规则：1. 实现Comparable接口，指定比较规则（当key是自定义对象时，需要让类继承该接口，并重写compareTo方法，以此来指定比较规则）；2. 创建集合时传递Comparator比较器对象，指定比较规则。若两种规则都写了，以第二种为准。

以key从大到小的顺序排列：

TreeMap<Integer, String> tm = new TreeMap<>(new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2- o1;
    }
});

Compareable接口，以学生的年龄递增为顺序，年龄相等则按照名字的顺序
(继承接口后有红色波浪线，选中并按alt+回车，选则implements methods，可以选择要重写的方法)

public class Student implements Comparable<Student>{
    private int age;
    private String name;
    //JavaBean省略
    @Override
    public int compareTo(Student o) {
        //o: 已经在红黑树中存在的元素
        //this: 新添加的元素
        int i = this.getAge() - o.getAge();
        i = i == 0 ? this.getName().compareTo(o.getName()) : i;
        //这一行的compareTo()是String的方法
        return i;
    }
}

数据结构

二叉树

红黑树

添加节点的规则：
在这里插入图片描述

栈Stack

先进后出（FILO）。元素的添加与删除只能在栈的顶部进行。

创建及方法

Stack<Object> sta = new Stack<>();
sta.push(Object o);//压栈
Object o1 = sta.pop();//出栈

其他

获取对象的类
Java中所有的对象都继承java.lang.Object类，Object提供了一个方法getClass()，用于返回对象的运行时类。可获得变量的数据类型。（只有引用数据类型可用）
```
String str = "aaa";
Class<?> cls = str.getClass();
System.out.println(cls.getName());
```

获取基本数据类型用instanceof（引用数据类型也可用）

if (obj instanceof Integer) {
    System.out.println("obj是int型");
} else if (obj instanceof Short) {
    System.out.println("obj是short型");
} else if (obj instanceof Float) {
    System.out.println("obj是float型");
} else if (obj instanceof Double) {
    System.out.println("obj是double型");
} else if (obj instanceof Long) {
    System.out.println("obj是long型");
} else if (obj instanceof Byte) {
    System.out.println("obj是byte型");
} else if (obj instanceof Character) {
    System.out.println("obj是char型");
} else if (obj instanceof Boolean) {
    System.out.println("obj是boolean型");
} else {
    System.out.println("obj不是基本数据类型");
}

huhuhuhuhuhu_hu

关注

24
点赞
踩
21

收藏

觉得还不错? 一键收藏
2
评论
Java笔记

定义格式：new(一般省略不写) String 变量名=“内容”//////字符串的内容是不能改变的，它的值在创建后不能被更改。字符串存储与串池内。当使用双引号直接赋值时，系统会检查该字符串在串池中是否存在，若不存在则创建新的字符串；若存在则复用。所以直接赋值可以节省内存（串池包含于堆内存，但串池和堆内存的地址要分开看）new出来的不会复用，而是开辟新的空间。
复制链接

扫一扫