Java系列笔记第三章：高级数据结构入门

最新推荐文章于 2021-09-28 14:29:55 发布

置顶 TonyBringwater

最新推荐文章于 2021-09-28 14:29:55 发布

阅读量265

点赞数 2

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/soldersun/article/details/106771478

版权

Java 专栏收录该内容

46 篇文章 0 订阅

订阅专栏

本文目录

1. Object类

java.lang.Object，是所有类的父类。

1.1 toString()方法

默认的toString()方法是直接输出对象的地址值。和直接输出对象的名字是一样的效果。
为了输出自己想要的东西，可以@Override toString()。
sout(obj)和sout(obj.toString())效果一致。

1.2 equals()方法

用来比较两个对象是否相等。
对于基本数据类型：比较的是值
对于引用类型：比较的是两个对象的内存地址

注意：equals(Object obj)传进来的是Object类的对象，有可能遇到多态的弊端：无法使用子类特有的变量或方法。使用向下转型（强制类型转换）把Object转换为某类。转换之前，需要用instanceof来判断是否是同一个子类。

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Zi zi = (Zi) o;
        return num == zi.num;
    }

idea自动添加的equals代码，其中getClass() != o.getClass()叫反射。

1.3 Objects类

提供了静态方法，这些静态方法是空指针安全的。

Objects.equals(o1,o2)

public static boolean equals(Object a, Object b) {
        return (a == b) || (a != null && a.equals(b));
    }

先判断内存地址是否相同，再调用equals()

2. 日期类

java.util.Date 精确到毫秒
1970年1月1日 00:00:00:0000代表的就是0ms(GMT时间)
long currentTime = System.currentTimeMillis()，返回从0ms到现在经过的毫秒，

2.1 Date类的空构造函数

import java.util.Date;

Date date = new Date();
System.out.println("现在时间是：" + date);

//========输出=========//
现在时间是：Sat May 16 17:57:37 CST 2020

2.2 Date类的带参数构造函数

Date date = new Date(long time)传进去毫秒，转换为日期。

import java.util.Date;

Date date = new Date(0);
System.out.println("0ms的日期是：" + date);

//========输出=========//
0ms的日期是：Thu Jan 01 08:00:00 CST 1970

2.3 Date.getTime()方法

long time = new Date().getTime()
Date date = new Date(); long time = date.getTime()
等同于long currentTime = System.currentTimeMillis()

3. DateFormat类

java.text.DateFormat，是一个用于格式化时间的抽象类。

格式化：日期 -> 文本; 解析：文本 -> 日期。
String format(Date date)

按照指定的格式，把日期格式化为字符串
Date parse(String source)

按照指定的格式，把字符串解析为日期。
这个类是个抽象类，我们可以用java.text.SimplyDateFormat类，这是DateFormat的子类。
构造函数：SimpleDateFormat(String pattern)
pattern:

字母含义
y 年
M 月
d 日
H 时
m 分
s 秒
S 毫秒

字母	含义
y	年
M	月
d	日
H	时
m	分
s	秒
S	毫秒

"yyyy-MM-dd HH:mm:ss"就是"2020-05-16 19:01:20"的意思

注意： 字母不能改，连接符可以改。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateFormatDemo {
    public static void main(String[] args) {
        String pattern = "yyyy年MM月dd日 HH时mm分ss秒";
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
        String stime = simpleDateFormat.format(new Date());
        System.out.println(stime);
        System.out.println("=====================");
        try {
            Date date = simpleDateFormat.parse(stime);
            System.out.println(date);
        } catch (ParseException e) {
            e.printStackTrace();
            System.out.println(e);
        }
    }
}
//=========输出=========//
2020年05月16日 19时10分19秒
=====================
Sat May 16 19:10:19 CST 2020

4. Calendar类

java.util.Calendar

抽象类，但是提供了一个直接获取实例的方法
Calendar now = Calendar.getInstance();

4.1 Calendar类的方法

public int get(int field) 返回指定字段的值

int year = now.get(Calendar.YEAR)

字段	含义
DATE	当前月的第几天
DAY_OF_WEEK	当前周的第几天
DAY_OF_WEEK_IN_MONTH	当前月中的第几个星期
HOUR	12小时制的小时
HOUR_OF_DAY	24小时制的小时
MINUTE	分钟
SECOND	秒
MILLISECOND	毫秒

下面四个是设置日期
public final void set(int field, int value)
public final void set(int year, int month, int date)
public final void set(int year, int month, int date, int hourOfDay, int minute)
public final void set(int year, int month, int date, int hourOfDay, int minute, int second)
abstract void add(int field, int amount) 根据日历的规则，为给定的日历字段添加或减去指定的时间量。
Date getTime() 返回一个表示此 Calendar 时间值（从历元至现在的毫秒偏移量）的 Date 对象。

5. System类

java.lang.System

5.1 public static long currentTimeMillis()

获取当前系统时间与1970年1月1日 00:00:00的毫秒差值

5.2 arraycopy()

public static void arraycopy(Object src,
int srcPos,
Object dest,
int destPos,
int length)

src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。

6. StringBuilder类

可变字符序列

6.1 构造函数

无参构造，生成一个空的。StringBuilder sb = new StringBuilder()
参数为一个字符串的构造函数，用字符串初始化这个StringBuilder。
初始化长度为16。

6.2 常用函数

sb.append(…)，添加任意类型数据的字符串形式。
sb.toString()，返回sb的字符串形式。

String s = "abc";
StringBuilder sb1 = new StringBuilder();
StringBuilder sb2 = new StringBuilder(s);
sb2.append("12");
sb1.append("ggg");
sb2.append(sb1);

System.out.println(sb2);

//=============输出=============//
abc12ggg

7. 包装类

装箱、拆箱

用Integer举例

7.1 装箱

把基本数据类型的数据装进包装类

构造方法(已过时)
1. Integer(int value)
2. Integer(String s)
静态方法
1. Integer.valueOf(int value)
2. Integer.valueOf(String s)

7.2 拆箱(成员方法)

在包装类中取出基本数据类型的数据

Integer in = 123

int in.intValue()
long in.longValue()

7.3 自动装箱与自动拆箱（JDK 1.5+）

7.4 基本类型与字符串的相互转换

7.4.1 基本类型->字符串

基本类型的值+空字符串

String s = 123+"";
包装类的静态方法(Integer为例)

Integer.toString(int i)
String类的静态方法

String.valueOf(int i)

7.5 字符串->基本类型

基本类型的静态方法

Integer.parseInt(String s)
Double.parseDouble(String s)

8. Collection集合

8.1 集合和数组的区别

数组长度不可变，集合长度可变。
数组中存储的都是同一类型的数据，集合中可以存储不一样类型的对象。
数组可以存储基本类型和对象，集合只能存储对象。

8.2 Collection的方法

add(E) : 添加内容，类似于vector的push_back()。
clear() : 移除此 collection中的所有元素。
remove(E) : 从此 collection中移除指定元素的单个实例，不存在的话返回false。
contains(E) : 如果此 collection 包含指定的元素，则返回 true。
isEmpty() : 如果此 collection 不包含元素，则返回 true。
size()
toArray() : 返回包含此 collection 中所有元素的数组。

8.3 Iterator 迭代器

hasNext() 是否有下一个元素。
next() 取出下一个元素。
Iterator是个接口，对象需要通过Collection对象的.iterator()方法来获取。

package CollectionDemo;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class test {
    public static void main(String[] args) {
        Collection<String> col = new ArrayList<>();
        col.add("12");
        col.add("46");
        col.add("26");
        col.add("456");
        col.add("356");
        Iterator<String> i = col.iterator();
      //方法1：通过显式迭代器
        while (i.hasNext()) System.out.println(i.next());
      //方法2：通过语法糖，增强的for循环，隐式迭代器
      //JDK1.5开始
      	for(String s:col) System.out.println(s);
    }
}

Tips : 通过增强的for循环迭代时，不可对集合进行增删操作

9. 泛型

是一种未知的数据类型

Element E
Type T

9.1 定义和使用含有泛型的类

9.1.1 定义方式：在类名后面加上

package GenericClassDemo;

public class GenericClass<E> {
    private E obj;

    public GenericClass(E obj) {
        this.obj = obj;
    }

    public E getObj() {
        return obj;
    }

    public void setObj(E obj) {
        this.obj = obj;
    }
}

9.1.2 使用：新建对象时在类名后面加上<具体用的类型>

package GenericClassDemo;

public class test {
    public static void main(String[] args) {
        GenericClass<String> s = new GenericClass<>();
        s.setObj("abc");
        System.out.println(s.getObj());
    }
}

//=============输出==============//
abc

9.1.3 定义含有泛型的方法

泛型定义在方法的修饰符与返回值类型之间。

普通泛型方法

//这样就能实现传进来任意类型的参数的功能
public <M> int fun(M m){
  System.out.println(m);
  return 1;
}

静态泛型方法

public static <M> void fun(M m){
  System.out.println(m);
}

9.2 定义和使用含有泛型的接口

9.2.1 定义含有泛型的接口

package GenericInterfaceDemo;

public abstract class GenericInterface<E> {
    abstract void method(E e);
}

9.2.2 使用含有泛型的接口

接口的实现类指定泛型类型

在实现接口时，指定泛型的类型，实现接口的类里面直接使用指定的类型即可。

package GenericInterfaceDemo;

public class GenericInterfaceImpl_1 extends GenericInterface<String> {
    @Override
    void method(String s) {
        System.out.println(s);
    }
}

接口的实现类跟着泛型走

实现接口时不指定泛型类型。

package GenericInterfaceDemo;

public class GenericInterfaceImpl_2<E> extends GenericInterface<E> {

    @Override
    void method(E e) {
        System.out.println(e);
    }
}

9.3 泛型通配符<?>

一旦使用泛型通配符，只能用Object中的方法。

注意：此时只能接受数据，不能往集合中存储数据。不能用来创建对象，只能在方法里使用。

package GenericInterfaceDemo;

import java.util.ArrayList;
import java.util.Iterator;

public class test {
    public static void main(String[] args) {
        ArrayList<String> l1 = new ArrayList<>();
        ArrayList<Integer> l2 = new ArrayList<>();
        l1.add("a");
        l1.add("b");
        l1.add("c");
        l2.add(1);
        l2.add(2);
        l2.add(3);

        printArray(l1);
        printArray(l2);
    }

    private static void printArray(ArrayList<?> obj) {
        //快速迭代器, 增强for循环
        for (Object o : obj) {
            System.out.print(o + " ");
        }
        System.out.println();
        //普通迭代器
        Iterator<?> iterator = obj.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();
    }
}

//===============输出==============//
a b c
a b c
1 2 3
1 2 3

9.4 受限通配符

9.4.1 上限 <? extends 某个类>

表示只接受这个类以及它的子类。

9.4.2 下限 <? super 某个类>

表示只接受这个类以及它的超类。

9.5 Collections类

操作集合的工具类 java.util.Collections

Collections.shuffle(List<?> list)

使用指定的随机源对List进行置换，将List随机打乱。

TonyBringwater

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java系列笔记第三章：高级数据结构入门

本文目录1. Object类1.1 toString()方法1.2 equals()方法1.3 Objects类2. 日期类2.1 Date类的空构造函数2.2 Date类的带参数构造函数2.3 Date.getTime()方法3. DateFormat类4. Calendar类4.1 Calendar类的方法5. System类5.1 public static long currentTimeMillis()5.2 arraycopy()6. StringBuilder类6.1 构造函数6.2 常用函
复制链接

扫一扫