week03

最新推荐文章于 2024-07-21 22:27:18 发布

小心点，我很强

最新推荐文章于 2024-07-21 22:27:18 发布

阅读量34

点赞数

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/m0_52436555/article/details/129219850

版权

java基础专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Week03

一、String

是什么：

sting是字符串，是字符的合集，一经创建不可改变，只能通过重建才能进行操作。

为什么：

对于大多数数据都不是个体，而是许多个字符的组合，为了记录更多的数据吧

怎么做：

String s1 = new String("aaa");
char[] a = {'1','2','3','4'};
String s2 = new String(a);

1.2 String 中的一些基本方法

1.查找类
String s1 = "123456789abcabc";
//根据下标找元素
s1.charAt(1);
//根据元素找下标(最先出现的)
s1.indexOf('1');
//根据元素找下标(最后出现的)
s1.lastIndexOf('a');

2.判断类
String s1 = "aaabb";
String s2 = "aaa";

//判断是否为空
s1.isEmpty();
//判断是否相等
s1.equals(s2);
//判断某字符是否为子串
s1.contains("a");
//判断字符是否以...开始
 s1.startsWith("aa");
//判断字符是否以...结束
s1.endsWith("bb");
//不考虑大写比较
s1.equalsIgnoreCase(s2);

3.转换类
//小写转大写
s1.toUpperCase();
//大写转小写
s1.toLowerCase();
//字符串转字符数组
s1.toCharArray();

4.字符串截取和替换

s1.replace(String s1,String s2);
s1.substring(int start,int end);

5.连接，长度，分离，去括号

s1.length();
s1.concat();
String[] split(String s1);
s1.trim;

二、StringBuffer

是什么：

同String, 不过可以对自己进行操作，不用重新创建对象。

为什么：

String在用的时候需要不断的创建对象，如果对于大量的数据进行操作就会导致空间使用过多，然后就会使其效率变低。所以需要StringBuffer来提高效率

怎么做：

1.通过构造方法把 String 对象变成 StringBuffer 对象
StringBuffer sb = new StringBuffer(String s1);

2.StringBuffer 中的方法

（增删改查）

//添加
sb.append();
//删除范围内的元素
sb.delete(int start, int end); 
//删除指定的元素
sb.deleteCharAt(int index);
//插入
sb.insert(int offset, String b);
//替换
sb.replace(int start, int end, String str); 
//反转
sb.reverse();
//修改
sb.setCharAt(int index, char ch);

三、StringBuilder

同StringBuffer一样，只是这个不安全，但效率高

四、Date

是什么：

是一个定义好的日期类，用户可以通过该类进行日期设定

为什么：

需要获取时间来进行操作

怎么做：

//1.通过构造方法直接获取当前时间
Date date = new Date();

//2.通过构造方法获取距离1970年指定毫秒后的时间数
Date date = new Date(100);

//3.设置和获取毫秒值
long time = date.getTime();
date.setTime();

2.SimpleDateFormat

是什么：

是对日期格式化和解析的类

为什么：

给定日期格式，方便他人观看

怎么做：

把日期变成字符串或者把字符串变成日期

//1.格式化模板
SimpleDateFormat sdf =  new SimpleDateFormat("yyyy年 mm月 dd日 HH 时");

//2.日期格式化文本
Date d = new Date();
String format = sdf.format(d);
//3.文本解析日期
String str = "2020-01-01";
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-mm-dd");
Date date = sdf1.pares;

3 Calendar

Calendar日历类,抽象类,不能直接创建对象使用,需要使用静态方法获得对象
 Calendar rightNow = Calendar.getInstance();
该类提供了很多静态常量属性(字段)用来代表某一时间,可以放在set() get()内使用

五、异常

是什么：

程序出现错误，解决错误的类

为什么：

为了解决异常错误

知识点：

所有异常的父类是：Throwable

Throwable向下分类又分为两大类：Error 和 Exception 其中

Error 错误是比较严重的错误，必须抛出，不能捕获

Exception 是一般错误，既可以抛出，又可以捕获其中 Exception 又可以分为

编译期异常和运行时异常

常见的编译期异常有解析异常

运行时异常有空指针异常，算术运算异常，下标越界异常…

怎么做：

//1.产生异常

throw new Exception();

//2.异常处理  抛出或者捕获

try{
    //可能异常的代码
}catch(Exception e){
    //异常处理
}finally{
    //结束程序
}

throws
    
//3.异常的方法
//得到异常信息
String getMessage();
//打印异常信息
printStaticTrace()

2.自定义异常

自定义子类继承Exception类，重写父类不带参数和带一个参数的构造方法，再给一个静态id防止并发

六、集合

是什么：

用来存储多个数据的一个容器。集合最开始是用来存储一系列的数据，不过后来通过不断的实践发现，一个集合中只需要存入一种相同的元素即可，于是就衍生到了泛型

泛型就是为了减少数据之间的强制转换，不然可能会影响数据。

为什么：

使用户可以更好的对相同数据的操作。

集合：

collection 是单列集合层次结构中的根接口

里面中的数据既可以是有序的也可以是无序的既可以重复又可以不重复

往下划分可以分为两大类

list：（有序，允许重复）

list 可以分为 ArrayList 和 LinkedList

set：（不允许重复）

set 可以分为 TreeSet 和HashSet，LinkedHashSet

map

1.Collection

Collection 是个接口，所以使用他的时候需要创建子类的对象

//集合中存放的是包装类，不过元素可以自动装箱拆箱
Collection collection = new ArrayList();

2.迭代

迭代器：Iterator

Collection<String> a = new ArrayList();
a.add("1");
a.add("2");
a.add("3");
Iterator<String> iterators = a.iterator();
while(iterators.hasNext()){
    System.out.println(iterators.next());
}

注意：

迭代器无法回退，对元素进行操作只能用自己的方法进行，不能多次调用next，不然遍历到最后一位元素时，无法访问最后两个元素，就会报错。

用它的子类 ListIterator 可以有删除，添加的功能

ArrayList<String> a = new ArrayList();
a.add("1");
a.add("2");
a.add("3");
ListIterator<String> it = a.listIterator();
while(it.hasNext()){
    it.add("4");
    it.remove();
    it.next();
}

foreach循环

//语法
for(数据类型 数据名 : 要遍历的集合名){
    数据名.方法名();
}

3.ArrayList

底层就是数组，添加元素会扩容

底层原理

ArrayList 底层是数组，默认容量是10，可以修改容量

如果没有到达容量就正常添加

如果到达容量，就新建一个数组，把容量扩大到原来的1.5倍，然后进行数组拷贝

ArrayList 特点：

可以重复，有序，查询效率高，删除效率低

4.LinkedList

底层原理：

底层是双向链表，所以有对头和尾的操作，没有固定容量

同样允许重复，有序查找效率低，插入删除效率高

5.HashSet

set 不能有重复元素

底层原理：

底层是hash表，不允许重复，没有顺序

扩容原理：（面试题）

去重原理：

1.调用add方法时，会在底层的 hashcode 方法来获得对象的地址值

2.如果地址值不一样就直接存取

3.如果地址值一样就接着比较 equals 方法比较元素内容是否一样

4.如果不一样就进行存储，如果一样就舍去

用工具生成 hashcode 和 equals 方法就可以进行去重判定

6、LinkedHashSet

既有 HashSet 的去重特性，又有 Linked 的排序特性，所以 LinkedHashSet ,既能去重又能排序。

7、TreeSet

既去重，又排序

去重排序原理：

底层时平衡二叉树（红黑树）

代码实现：

1.实现 Comparable 接口，重写 comparTo 方法

public class User implements Comparable<User>{
// 属性和方法...
    
/**
 * this 是指代正在存储的元素
 * o    是之前存储的元素
 */
@Override
    public int compareTo(User o) {
        System.out.println("此对象--> " + this);
        System.out.println("指定对象--> " + o);
        // 姓名和年龄相同返回0,即去重不存储
        if (this.name.equals(o.getName()) && this.getAge() - o.getAge() == 0) {
            return 0;
        }
        // 年龄相同返回1,即保留下来的不去重的意思
        // 年龄不同的话就正常相减,返回负数或正数
        return this.getAge() - o.getAge() == 0 ? 1 : this.getAge() - o.getAge();
    }
}