Java笔记

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. 成员内部类
    写在成员位置的,属于外部类的成员。
  • 获取成员内部类对象的方式:1. 当成员内部类被private修饰时,在外部类编写方法,对外提供内部类对象。2. 当成员内部类被非私有修饰时,直接创建对象。Outer.Inneer oi = new Outer().new Inner();
  • 外部类成员变量和内部类成员变量重名时,在内部类的访问方法:Outer.this.变量名
  1. 静态内部类
    静态内部类是成员内部类的一种
  • 格式:
    创建静态内部类对象:外部类名.内部类名 对象名 = new 外部类名.内部类名();
    调用静态方法:外部类名.内部类名.方法名();
  • 静态内部类只能访问外部类中的静态变量和静态方法,若访问非静态的需要创建外部类的对象。
  1. 局部内部类
    将内部类定义在方法里面就叫做局部内部类,类似于方法里面的局部变量。
  • 外界无法直接使用局部内部类,需要在方法内部创建对象并使用。
  • 局部内部类可以直接访问外部类的成员,也可以访问方法内的局部变量。
  1. 匿名内部类
    用于只需要用一次的时候

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对象“
  • 方法

    1. 基本方法

      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);
      
    2. entrySet();
      返回的是键值对对象

  • 遍历

    1. 用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());
       	}
      
    2. 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());
      }
      
    3. 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不是基本数据类型");
    }
    
    
  • 24
    点赞
  • 21
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值