Java复习五（List、Set、Map、String类、StringBuilder类、日期、日历类）

淡忘728

已于 2022-12-03 11:15:17 修改

阅读量253

点赞数

文章标签：数据结构

于 2022-12-02 17:49:05 首次发布

本文链接：https://blog.csdn.net/weixin_65824274/article/details/128075872

版权

List和Set的顶层接口都是Collection

数组与集合的区别：

1.数组长度固定，集合长的可变

2.数组存储同一类的数据，可以存储基本数据类型、对象、引用数据类型

集合存储的都是对象，不能存储基本数据类型，存储的是对应的包装类

List(列表)是有序的(存和取的顺序一致)有索引，且元素可以重复 (常用子类1、2)

1.ArrayList就是一个动态的数组；特点：查询快、增删慢

2.LinkedList基于链表的存储结构；特点：查询慢、增删快；可以根据尾部和首部来操作数据
ArrayList新增元素比较麻烦，在最后面开辟新的空间，元素依次往后移动，空出来的位置，插入新元素
LinkedList直接把两个元素的关系断开，构建与新元素的联系

常用方法

add(String item)向滚动列表的末尾添加指定的项。

add(String item, int index)向滚动列表中索引指示的位置添加指定的项。

remove(int position)从此滚动列表中移除指定位置处的项。

remove(String item)从列表中移除项的第一次出现。

removeAll()从此列表中移除所有项。

 List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        //list可以通过索引获取元素，或者使用for循环遍历元素，或者使用迭代器
        System.out.println(list.get(0));
        System.out.println("迭代元素：");
        //普通for循环通过索引获取集合元素的值
        /*for (int i = 0;i<list.size();i++){
            String s = list.get(i);
            System.out.println(s);
        }*/
        //增强for循环，不断的从list取出元素，赋值给临时变量s
        for (String s : list) {
            System.out.println(s);
        }

Set(集)

1.存储的元素是不可重复的，并且元素都是无序的(存和取的顺序不一致)无索引

2.不能直接获取某个元素，只能通过迭代器遍历元素。

通俗的理解为小学生的书包，直接把元素扔进去，是没有任何顺序的，所以元素不能重复。

 Set<String> set = new HashSet<>();
        set.add("z");
        set.add("x");
        set.add("y");
        System.out.println(set);
        //set不能直接获取某个元素，只能通过迭代器遍历元素
        Iterator<String> iterator = set.iterator();
        while(iterator.hasNext()){
            String temp = iterator.next();//取出元素
            System.out.println(temp);
        }

Map(映射)

基于键值对形势存储的数据结构

在Map中key是不允许重复的，value值可以重复。

Map会把所有的key存放在一个Set集合中。

Map<String,Object> map = new HashMap<>();
        map.put("name","张三");
        map.put("age",20);
        map.put("sex","男");
        System.out.println(map);
        //Map的遍历，首先需要获取所有的key值(是一个set集合),然后根据key值获得对应的value值
        Set<String> keySet = map.keySet();//获取map中的key值的set集合
        Iterator<String> ite = keySet.iterator();
        while(ite.hasNext()){
            String key = ite.next();//获取key值
            Object value = map.get(key);//map通过Key值获取value值
            System.out.println(key+"-->"+value);
        }

String类

不变性：只要使用String赋值后，这个字符串会一直在内存中存在，因为它具有不变性，String 本身是一个不可变的字符数组；如果改变字符串的值，不是改变字符本身，而是重新创建或找到一个相同的字符串。更改地址引用。

package test7;

public class Test1 {
    public static void main(String[] args) {
        //1.标准的堆栈定义类类型变量的赋值，脑海中要有一张图
        String s1 = new String("abc");
        s1 ="xyz";
        /*2.String直接赋值的原理:
        直接在内存中查找，有没有一个abc的字符串，如果存在该字符串，则把它的地址赋值给s2变量，不存在，创建一个abc,然后把地址赋值给s2变量
         */
        String s2 = "abc";
        String s3 = "abc";
        int a =5;
        // System.out.println(s2==s3);
        /*只要使用String赋值后，这个字符串会一直在内存中存在，因为它具有不变性，String 本身是一个不可变的字符数组；
        如果改变字符串的值，不是改变字符本身，而是重新创建或找到一个相同的字符串。更改地址引用。
        经常变化的字符串不推荐使用String定义，因为变化一次就会在内存中创建一个字符串；
        Java有-个强大的垃圾回收机制，自动释放垃圾资源*/
        s2 = "xyz";//不是修改值，而是更改引用的值
    }
}

定义一个字符串的方法

String() 初始化一个新创建的 String 对象，使其表示一个空字符序列。

String(byte[] bytes) 通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。

String(byte[] bytes, int offset, int length) 通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。

String(char[] value) 分配一个新的 String，使其表示字符数组参数中当前包含的字符序列。

String(char[] value, int offset, int count) 分配一个新的 String，它包含取自字符数组参数一个子数组的字符。

String(String original) 初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本。

package test7;
//定义String的七种方法
public class Test2 {
    public static void main(String[] args) {
        String s1 = "abc";//引用内存中abc字符串的地址
        String s2 = new String();//创建一个空字符串
        byte[] bytes1 = {97,98,99,100,101,102,103,104};//byte范围是-128---127
        String s3 = new String(bytes1);//把byte数组中的整数值按照ASCII码表解析成字符串---)abcdefgh
        byte[] bytes2 = {97,98,99,100,101,102,103,104};//照ASCII码表解析abcdefgh
        String s4 = new String(bytes2,2,3);//把byte数组中的整数值,从索引2的元素开始截取3个长度，按照ASCII码表解析成字符串---）cde
        char[] chars1 = {'a','b','c','d','e'};
        String s5 = new String(chars1);//把字符串数组转换成字符串---）abcde
        char[] chars2 = {'a','b','c','d','e'};
        String s6 = new String(chars2,2,2);//把字符串数组从索引2的元素开始截取2个长度转换成字符串---）cd
        String s7 = new String("abcd");//abcd
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s4);
        System.out.println(s5);
        System.out.println(s6);
        System.out.println(s7);
    }
}

常用方法

charAt(int index) 返回指定索引处的 char 值。

concat(String str) 将指定字符串连接到此字符串的结尾。也就是字符串的拼接;

contains(CharSequence s) 当且仅当此字符串包含指定的 char 值序列时，返回 true。

endsWith(String suffix) 测试此字符串是否以指定的后缀结束。

equals(Object anObject) 将此字符串与指定的对象比较。

getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。

lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。

substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。

toCharArray() 将此字符串转换为一个新的字符数组。

length() 返回此字符串的长度。

replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

split(String regex) 根据给定正则表达式的匹配拆分此字符串。

toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

trim() 返回字符串的副本，忽略前导空白和尾部空白

代码示例

package test7;

public class Test3 {
    public static void main(String[] args) {
        String s1 = "abcdefghello";
        char c = s1.charAt(2);//获取字符串中指定索引位置的元素
        System.out.println(c);

        int i = s1.length();//返回此字符串的长度
        System.out.println(i);

        boolean b4 = s1.equals("abc");//将此字符串与指定的对象比较
        System.out.println(b4);

        String s2 = s1.concat("xyz");//字符串的拼接，把s1字符串拼接上xyz
        System.out.println(s2);

        String s3 = "JavaTest.txt";
        boolean b3 = s3.endsWith(".txt");//判断字符串是否以.txt结尾，常常用来判断文件名的后缀
        System.out.println(b3);

        boolean b1 = s1.contains("x");//当且仅当此字符串包含指定的 char 值序列时，返回 true
        boolean b2 = s2.contains("x");
        System.out.println(b1);
        System.out.println(b2);

        String s4 = "abcdefcdxyz";
        byte[] bytes = s4.getBytes();//把字符串按照ASCII码表解析成byte数组
        char[] chars = s4.toCharArray();//把字符串转换成字符数组
        System.out.println(bytes);
        System.out.println(chars);

        String s5 = "Bad weather fuck the weather";
        String r= s5.replace("fuck", "****");//把字符串中出现fuck转化为****
        System.out.println(r);

        String s6 = "abcdefg";
        String s7 = s6.substring(2, 5);//截取字符串，从第2个索引开始截取到第5个索引，不包含第5个索引
        System.out.println(s7);

        String s8 = "app/code/java/day01";
        String[] split = s8.split("/");//按照/拆分字符串形成字符串数组["app","code","java",day01"]
        for (String s : split) {
            System.out.println(s);
        }

        String s10 = "    面包    ";
        System.out.println(s10);
        String s11 = s10.trim();//去除字符串前后的空白
        System.out.println(s11);

        String s12 = "abcddd";
        int i1 = s12.indexOf(0);//返回指定字符在此字符串中第一次出现处的索引
        System.out.println(i1);

        String s13 = "abcdABC";
        String s14 = s13.toLowerCase();//使用默认语言环境的规则将此 String 中的所有字符都转换为小写
        String s15 = s13.toUpperCase();//使用默认语言环境的规则将此 String 中的所有字符都转换为大写
        System.out.println(s14);
        System.out.println(s15);

        String s16 = "abcddd";
        int d = s1.indexOf("d");//返回指定子字符串在此字符串中第一次出现处的索引
        System.out.println(d);

        String s17 = "abbbadb";
        int i2 = s1.lastIndexOf("b");//返回指定子字符串在此字符串中最右边出现处的索引
        System.out.println(i2);
    }
}

static关键字

static修饰变量和方法，表示它们就是静态的。

1.它们会在编译阶段就再加到内存中；

2.它们是被类所有的对象公用的；

3.静态变量和方法可以直接通过类名访问；

Arrays类

包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

常用方法

toString(int[] a)返回指定数组内容的字符串表示形式。

sort(int[] a) 对指定的 int 型数组按数字升序进行排序。

package test7;

import java.util.Arrays;

public class Test5 {
    public static void main(String[] args) {
        int [] a = {3,1,5,6,2};
        System.out.println(Arrays.toString(a));//把数组打印输出
        Arrays.sort(a);//实现数组的排序
        System.out.println(Arrays.toString(a));

    }

}

日期类

Date类

在类 Date 所有可以接受或返回年、月、日期、小时、分钟和秒值的方法中，将使用下面的表示形式：

年份 y 由整数 y - 1900 表示。
月份由从 0 至 11 的整数表示；0 是一月、1 是二月等等；因此 11 是十二月。
日期（一月中的某天）按通常方式由整数 1 至 31 表示。
小时由从 0 至 23 的整数表示。因此，从午夜到 1 a.m. 的时间是 0 点，从中午到 1 p.m. 的时间是 12 点。
分钟按通常方式由 0 至 59 的整数表示。
秒由 0 至 61 的整数表示；值 60 和 61 只对闰秒发生，尽管那样，也只用在实际正确跟踪闰秒的 Java 实现中。于按当前引入闰秒的方式，两个闰秒在同一分钟内发生是极不可能的，但此规范遵循 ISO C 的日期和时间约定。

package Test8;

import java.util.Date;

public class DateTest01 {
    public static void main(String[] args) {
        //日期类型:出生日期 下单时间 付款时间 预约时间
        //类 Date 表示特定的瞬间，精确到毫秒
        Date date1 = new Date();//获取当前的时间
        System.out.println(date1);
        Date date2 = new Date(1000);//创建距离1970年1月1日 08:00:00(中国东八区)经过了多少毫秒的时间
        System.out.println(date2);
    }
}

SimpleDateFormat类

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类。它允许进行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。

常用方法

format(Date date, StringBuffer toAppendTo, FieldPosition pos) 将给定的 Date 格式化为日期/时间字符串，并将结果添加到给定的 StringBuffer。

parse(String text, ParsePosition pos) 解析字符串的文本，生成 Date。

package Test8;

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

public class DateFormatTest02 {
    public static void main(String[] args) throws ParseException {
        Date date = new Date();
        //SimpleDateFormat是DateFormat的子类，用来做日期和字符串之间的相互转换
        //实例化日期格式化类，指定格式化的格式样式
        SimpleDateFormat  sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");

        //日期格式化成字符串
        String format = sdf.format(date);
        System.out.println(format);

        //字符串解析成日期
        String time = "2000/10/15 08:10:20";
        Date date2 = sdf.parse(time);
        System.out.println(date2);
    }
}

日历类

Calendar类

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。瞬间可用毫秒值来表示，它是距历元（即格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，格里高利历）的偏移量。

与其他语言环境敏感类一样，Calendar 提供了一个类方法 getInstance，以获得此类型的一个通用的对象。Calendar 的 getInstance 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化：

Calendar rightNow = Calendar.getInstance();

获得并设置日历字段值

可以通过调用 set 方法来设置日历字段值。在需要计算时间值（距历元所经过的毫秒）或日历字段值之前，不会解释 Calendar 中的所有字段值设置。调用 get、getTimeInMillis、getTime、add 和 roll 涉及此类计算。

字段

MONTH 指示月份的 get 和 set 的字段数字。

DAY_OF_YEAR get 和 set 的字段数字，指示当前年中的天数。

YEAR 指示年的 get 和 set 的字段数字。

常用方法

getTime() 返回一个表示此 Calendar 时间值（从历元至现在的毫秒偏移量）的 Date 对象。

package Test8;

import java.util.Calendar;
import java.util.Date;

public class CalendarTest03 {
    public static void main(String[] args) {
        //Calendar的getInstance()方法返回一个Calendar对象
        Calendar calendar = Calendar.getInstance();
        //获取当前时间
        Date time = calendar.getTime();
        System.out.println(time);

        //可以获取当前时间任何你想要获取的信息
        int year = calendar.get(calendar.YEAR);//获得当前时间的年份
        System.out.println("年份："+year);
        int month = calendar.get(calendar.MONTH);
        System.out.println("月份："+month);
        int dayOfYear = calendar.get(calendar.DAY_OF_YEAR);
        System.out.println("本年第："+dayOfYear+"天");
        //Calendar可以通过get方法指定字段值来获取当前时间的一些信息

        //指定年月日、时分秒 月份0-11表示1-12月
        calendar.set(2022,11,25,23,59,59);

        //获取当前时间
        Date date1 = calendar.getTime();
        System.out.println(date1);
    }
}

System类

System 类包含一些有用的类字段和方法。它不能被实例化。在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。

常用方法

arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

currentTimeMillis() 返回以毫秒为单位的当前时间。

String类定义出来的字符串具有不变性  
一般不做经常变化字符串的使用，经常需要变化的推荐使用StringBuffer或者StringBuilder
StringBuffer 线程安全的可变字符串序列
StringBuilder 线程不安全的可变字符串序列
StringBuffer和StringBuilder都是操作的字符串本身

package Test8;

public class SystemTest04 {
    public static void main(String[] args) {
        //currentTimeMillis获取的是系统当前时间的毫秒值(时间戳)，可以用来做性能的测试，或者配合生成一些不重复的编号
        Long start = System.currentTimeMillis();//获取当前系统时间的毫秒值
        for (int i = 0; i < 100000; i++){
            //测试你书写的程序的运行效率
            System.out.println(i);
        }
        Long stop = System.currentTimeMillis();//获取当前系统时间的毫秒值
        System.out.println("十万次性能测试时间为:"+(stop-start)+"毫秒");
    }
}

StringBuilder类

常用方法

append(String str) 将指定的字符串追加到此字符序列。

charAt(int index) 返回此序列中指定索引处的 char 值。

delete(int start, int end) 移除此序列的子字符串中的字符。

insert(int offset, String str) 将字符串插入此字符序列中

代码示例

public class StringBuilderTest05 {
    public static void main(String[] args) {
        //如下代码会在内存中出现三个字符串，Hello、World、HelloWorld
        //String类在做字符串值变化的时候，非常浪费内容
        String s = "Hello";
        s+="World";
        System.out.println(s);

        StringBuilder sb1 = new StringBuilder();
        sb1.append("World");//对字符串后面进行追加内容
        System.out.println(sb1);

        sb1.insert(2,"x");//在字符串指定索引位置插入一个新的字符串
        System.out.println(sb1);

        StringBuilder sb2 = sb1.reverse();//字符串的反转
        System.out.println(sb2);

        StringBuilder sb3 = sb1.delete(2,4);//移除此序列的子字符串中的字符
        System.out.println(sb3);

        char c = sb1.charAt(2);//返回此序列中指定索引处的 char 值
        System.out.println(c);
    }
}

淡忘728

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java复习五（List、Set、Map、String类、StringBuilder类、日期、日历类）

不变性：只要使用String赋值后，这个字符串会一直在内存中存在，因为它具有不变性，String 本身是一个不可变的字符数组；如果改变字符串的值，不是改变字符本身，而是重新创建或找到一个相同的字符串。特点：查询慢、增删快；通俗的理解为小学生的书包，直接把元素扔进去，是没有任何顺序的，所以元素不能重复。1.存储的元素是不可重复的，并且元素都是无序的(存和取的顺序不一致)无索引。集合存储的都是对象，不能存储基本数据类型，存储的是对应的包装类。通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的。
复制链接

扫一扫