Java基础day19——String API 、集合和List

liang79096

已于 2024-04-16 09:43:10 修改

阅读量421

点赞数 3

文章标签： java 开发语言

于 2024-04-15 18:34:21 首次发布

本文链接：https://blog.csdn.net/liang79096/article/details/137790350

版权

1.正则表达式在StringAPI中

正则表达式查询网址：正则表达式手册

import org.junit.Test;

import java.util.Arrays;

public class StringAPI {

    /*
        正则表达式： 正则表达式是使用单个字符串用来描述和匹配一系列符合某个语法规则的字符串
     */
    @Test
    public void test(){
        // \d表示一个数字
        // + 表示前面的字符出现一次或多次
        System.out.println("123".matches("\\d+"));
        System.out.println("123".matches("\\d+"));

        //^ : 以什么开头
        //\D	匹配一个非数字字符。等价于[^0-9]。
        System.out.println("longgeheihei".matches("^long\\D+"));
    }

    /*
    （17）String replace(xx,xx)：不支持正则

    （18）String replaceFirst(正则，value)：替换第一个匹配部分

    （19）String replaceAll(正则， value)：替换所有匹配部分
     */
    @Test
    public void test2(){
        System.out.println("abcdaaa".replace('a','A'));
        System.out.println("abcdaaa".replaceFirst("a","A"));
        System.out.println("1abcdaaa".replaceFirst("\\d","f"));
        System.out.println("abcdaaa".replaceAll("a","A"));
    }
    /*
    String[] split(正则)：按照某种规则进行拆分
     */
    @Test
    public void test3(){
        String[] split = "a-b-c-d".split("-");
        System.out.println(Arrays.toString(split));
    }

}

2.StringBuffer和StringBuilder与API

1.介绍

区别 String 不可变

StringBuffer 和StringBuilder 为可变的字符序列

StringBuilder 线程不安全

import org.junit.Test;

/*
    [面试题]StringBuffer和StringBuilder的区别？

    String:         不可变的字符序列   线程安全
    StringBuffer:   可变的字符序列     线程安全
    StringBuilder:  可变的字符序列     线程不安全
 */
public class StringBufferTest {
    /*
        当我们使用StringBuilder的空参构造器创建对象时底层会创建一个长度为16的char类型数组。
        当我们向该数组中存放第17个元素时底层会进行扩容（创建一个新的数组该数组的长度为原来的2倍+2
                并且将原数组中的内容copy到新数组中）
     */
    @Test
    public void test(){
        //创建StringBuilder对象 - 空参构造器中创建了一个长度为16的char类型数组
        StringBuilder sb = new StringBuilder();
        sb.append("abcdef1111111111");
        sb.append("1");

        System.out.println(sb + " " + sb.length());//length:返回的是内容的长度

    }

    /*
        （1）StringBuffer append(xx)：拼接，追加
        
     */
    @Test
    public void test2(){
        StringBuffer sb = new StringBuffer();
        sb.append("aa");
        sb.append("bb");
        String str = null;
        sb.append(str);//会把null当成字符串放入到数组中。
        System.out.println(sb + " " + sb.length());
    }
    @Test
    public void test3(){
        String s = null;
        StringBuffer sb = new StringBuffer(s);//不能放null 因为底层会调用 s.length()
        System.out.println(sb.length());//4
    }
    
    /*
（2）StringBuffer insert(int index, xx)：在[index]位置插入xx
（3）StringBuffer delete(int start, int end)：删除[start,end)之间字符
（3）StringBuffer deleteCharAt(int index)：删除[index]位置字符
（5）void setCharAt(int index, xx)：替换[index]位置字符
（6）StringBuffer reverse()：反转
（7）void setLength(int newLength) ：设置当前字符序列长度为newLength
（8）StringBuffer replace(int start, int end, String str)：替换[start,end)范围的字符序列为str
     */
    @Test
    public void test4(){
        StringBuffer sb = new StringBuffer();
        sb.append("abcdef");

//        sb.insert(0,"111");//不要理解成在一个位置上放了3个1
//        sb.insert(1,"a");
//        System.out.println(sb);

        /*
        （3）StringBuffer delete(int start, int end)：删除[start,end)之间字符
        （3）StringBuffer deleteCharAt(int index)：删除[index]位置字符
         */
//        sb.delete(0,3);
//        sb.deleteCharAt(0);
//        System.out.println(sb);

        /*
        （5）void setCharAt(int index, xx)：替换[index]位置字符
        （6）StringBuffer reverse()：反转
         */
//        sb.setCharAt(1,'龙');
//        System.out.println(sb);
//        sb.reverse();//就是对当前数组中的内容进行反转
//        System.out.println(sb);

        /*
        （7）void setLength(int newLength) ：设置当前字符序列长度为newLength
        （8）StringBuffer replace(int start, int end, String str)：替换[start,end)范围的字符序列为str
         */
        //sb.setLength(2); //修改数组长度(比原来大就扩容 - 比原来小就缩容)
        sb.replace(0,2,"j");
        System.out.println(sb);

        //将StringBuffer转成String
        String s = sb.toString();
    }

}

2.效率

StringBuilder >StringBuffer >String

越不安全效率越高

package com.atguigu.java;

import org.junit.Test;

/*
    效率 : StringBuilder > StringBuffer > String
 */
public class TimeTest {

    @Test
    public void testString(){
        long start = System.currentTimeMillis();
        String s = new String("0");
        for(int i=1;i<=10000;i++){
            s += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("String拼接+用时："+(end-start));//296

        long memory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        System.out.println("String拼接+memory占用内存: " + memory);//334027408字节
    }

    @Test
    public void testStringBuilder(){
        long start = System.currentTimeMillis();
        StringBuilder s = new StringBuilder("0");
        for(int i=1;i<=10000;i++){
            s.append(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("StringBuilder拼接+用时："+(end-start));//1
        long memory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        System.out.println("StringBuilder拼接+memory占用内存: " + memory);//10066384
    }

    @Test
    public void testStringBuffer(){
        long start = System.currentTimeMillis();
        StringBuffer s = new StringBuffer("0");
        for(int i=1;i<=10000;i++){
            s.append(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("StringBuffer拼接+用时："+(end-start));//5
        long memory = Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory();
        System.out.println("StringBuffer拼接+memory占用内存: " + memory);//10066384
    }

    @Test
    public void test(){
        String s = "a";
        String s2 = "b";
        String s3 = s + s2;//底层用了StringBuilder
    }
}

3.集合

1.集合介绍及API

Collection 单列集合

Map双列集合- 键值对

Collection 下的接口LIst和Set

其二的实现分别为ArrayList、LinkedList 、 Vector 和HashSet、LinkedHashSet、TreeSet

重写了equals比较的是值，为重写比较的是地址

如果使用list 重写equals Set还要重写Hash

import org.junit.Test;

import java.util.*;
import java.util.function.Predicate;

/*
    集合:
        1.集合是Java提供的一种容器.集合是用来存储对象.
        2.集合和数组的区别
            ①数组的长度是不可变的,集合的长度可变.
            ②数组可以存放基本数据类型的数据和对象  集合只能存储对象.
        3.集合主要分Collection(单列集合)和Map(双列集合-键值对)
        4.Collection分成List和Set
            |------Collection
                |-------List : 存储的元素是有序的并且可以重复
                    |--------ArrayList
                    |--------LinkedList
                    |--------Vector
                |-------Set :  存储的元素是无序的并且不可以重复
                    |--------HashSet
                    |--------LinkedHashSet
                    |--------TreeSet


      CollectionAPI:
          注意:如果集合中存放的是自定义的类的对象那么该类必须重写equals方法 (重写hashCode方法-以后再说)
                (因为对集合中元素的操作底层都可能会用到equals方法).
 */
public class CollectionTest {
    /*
        Collection: 单列集合
     */
    @Test
    public void test(){
        //多态
        Collection c = new ArrayList();
        /*
        （1）add(E obj)：添加元素对象到当前集合中
        （2）addAll(Collection<? extends E> other)：添加other集合中的所有元素对象到当前集合中，
                即this = this ∪ other
         */
        c.add("a");
        c.add("b");

        Collection c2 = new ArrayList();
        c2.add("1");
        c2.add("2");

        //将c2中的元素分别放入到c中
        //c.addAll(c2);

        //将c2作为一个元素存放到c中
        c.add(c2);

        System.out.println(c);
        System.out.println(c.size());//获取元素的个数
    }

    /*
 （1） boolean remove(Object obj) ：从当前集合中删除第一个找到的与obj对象equals返回true的元素。
 （2）boolean removeAll(Collection<?> coll)：从当前集合中删除所有与coll集合中相同的元素。即this = this - this ∩ coll
（3）boolean retainAll(Collection<?> coll)：从当前集合中删除两个集合中不同的元素，使得当前集合仅保留与c集合中的元素相同的元素，即当前集合中仅保留两个集合的交集，即this  = this ∩ coll；
（4）void clear()：清空集合
（5）boolean removeIf(Predicate<? super E> filter) ：删除满足给定条件的此集合的所有元素。removeIf方法是**Java8**引入的。
     */
    @Test
    public void test2(){
        Collection c = new ArrayList();
        c.add("a");
        c.add("bb");
        c.add("ccc");

        Collection c2 = new ArrayList();
        c2.add("a");
        c2.add("e");


//        c.remove("a");//删除集合中的元素 如果有多个只删除第一个
//        System.out.println(c);

//        c.removeAll(c2); //删除c和c2交集的部分
//        System.out.println(c);

//        c.retainAll(c2); //只保留c和c2交集部分
//        System.out.println(c);

//        c.clear();
//        System.out.println(c);

        c.removeIf(new Predicate() {
            @Override
            public boolean test(Object o) {
                //向下转型
                String s = (String) o;
                //需求:只要集合中的元素的长度大于等于2就删除
                return s.length() >= 2; //如果返回值是true就删除当前元素
            }
        });

        System.out.println(c);
    }

    /*
（1）boolean isEmpty()：判断当前集合是否为空集合。
（2）boolean contains(Object obj)：判断当前集合中是否存在一个与obj对象equals返回true的元素。
（3）boolean containsAll(Collection<?> c)：判断c集合中的元素是否在当前集合中都存在。即c集合是否是当前集合的“子集”。
（4）int size()：获取当前集合中实际存储的元素个数
（5）Object[] toArray()：返回包含当前集合中所有元素的数组
     */
    @Test
    public void test3(){
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");

//        System.out.println(c.isEmpty());//当前集合是否为空
//        System.out.println(c.contains("aa"));//当前集合中是否包含"aa"

//        Collection c2 = new ArrayList();
//        c2.add("a");
//        c2.add("a");
//        c2.add("b");
//        System.out.println(c.containsAll(c2));//当前集合中是否包含c2中所有元素

        Object[] objects = c.toArray();//将Collection转成Object[]
        System.out.println(Arrays.toString(objects));
    }

    /*
        注意:
     */
    @Test
    public void test4(){
        Collection c = new ArrayList();
        c.add(new Person("abc",1));

        Person p1 = new Person("ccc",2);
        c.add(p1);

        c.add(new Person("ddd",3));
//        boolean isContains = c.contains(p1);

        /*
            注意:contains的判断是通过添加的对象的equals方法进行比较
                如果该对象所属的类没有重写equals方法比较的是地址值.
                如果重写了(重写就为了比内容)比较的是内容.
         */
//        boolean isContains = c.contains(new Person("ccc", 2));
//        System.out.println(isContains);


        /*
            注意:remove的判断是通过添加的对象的equals方法进行比较
                如果该对象所属的类没有重写equals方法比较的是地址值.
                如果重写了(重写就为了比内容)比较的是内容.
         */
        c.remove(new Person("abc",1));
        System.out.println(c);
    }
}

class Person{
    String name;
    int id;

    public Person(String name, int id) {
        this.name = name;
        this.id = id;
    }

    /*
        重写equals方法比较的是内容
     */
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return id == person.id && Objects.equals(name, person.name);
    }


    @Override
    public String toString() {
        return name + " " + id;
    }
}

2.迭代器

用来遍历集合

作用：获取指针的元素指针下移

HashNext（）用来找是否有下一个元素返回值为boolean类型

import org.junit.Test;

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

/*
    迭代器 ： 用来遍历集合中的元素
 */
public class IteratorTest {
    @Test
    public void test(){
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");

        //获取迭代器对象
        Iterator iterator = c.iterator();

        /*
            next() : ①获取指针指向的元素  ②指针下移
         */
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());

        /*
            hasNext() : 是否有下一个元素。如果有返回true没有返回false
         */
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }

    /*
        注意：每调用一次iterator()方法就会创建一个新的对象（就会产生新的指针）
     */
    @Test
    public void test2(){
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");

        //写法不对
        while (c.iterator().hasNext()){
            System.out.println(c.iterator().next());
        }
    }

    /*
        注意：
     */
    @Test
    public void test3(){
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");

        Iterator iterator = c.iterator();

        //下面的写法不对 -- 当没有元素的时候next就已经会发生异常了
        while (iterator.next() != null){
            System.out.println(iterator.next());
        }
    }
}

3.增强for循环

for循环格式 names。for（快捷键）

for循环在非集合底层是fori

for在集合中底层为迭代器

import org.junit.Test;

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

/*
    增强for循环

    作用： 用来遍历数组和集合

    格式：
        for(数据类型 变量名: 数组名/集合名){
            循环体;
        }
 */
public class ForEachTest {

    /*
        遍历数组
     */
    @Test
    public void test(){
        String[] names = {"哥哥","姐姐","妹妹","弟弟"};

        //快捷方式 : names.for

        //底层就是普通for循环 for(int i = 0; i < names.length; i++)
        for(String name : names){
            System.out.println(name);
        }
    }

    /*
        遍历集合
     */
    @Test
    public void test2(){
        Collection c = new ArrayList();
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");

        //底层是迭代器
        for(Object o : c){
            System.out.println(o);
        }
    }
}

4.list及API

说明：list是单列集合

继承了Collection接口未实现实现的有ArrayList LinkedList Vector

List中的元素是有序可重复的

import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.function.UnaryOperator;

/*
    List接口

    说明：
        1.List是单列集合
        2.List继承了Collection接口
        3.List中存放的元素是有序可重复的
        4.List常用的实现类有 ： ArrayList LinkedList Vector

     [面试题] ArrayList和Vecotr有什么区别？StringBuffer和StringBuilder有什么区别？

 */
public class ListTest {
    /*
     * void add(int index, E ele)：把元素添加到指定位置
     * boolean addAll(int index, Collection<? extends E> eles)：把一组元素添加到指定位置
     */
    @Test
    public void test(){
        //多态
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("longge");

//        list.add(0,"longge");
//        System.out.println(list);

        List list2 = new ArrayList();
        list2.add("1");
        list2.add("2");

        list.addAll(1,list2);
        System.out.println(list);
    }

    /*
        2、删除元素
        - E remove(int index)：删除指定位置的元素
        3、修改元素
        - E set(int index, E ele)：替换[index]位置的元素
        - default void replaceAll(UnaryOperator<E> operator)：按指定操作的要求替换元素
     */
    @Test
    public void test2(){
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add(1);//自动装箱了
        list.add("c");
        list.add("d");

//        list.remove("a");
//        System.out.println(list);

//        list.remove(1);//索引
//        list.remove(new Integer(1));//删除的是内容1
//        System.out.println(list);

//        list.set(0,"超人");
//        System.out.println(list);

        list.replaceAll(new UnaryOperator() {
            @Override
            public Object apply(Object o) {
                System.out.println(o.toString());
                return o+"龙哥我爱你";//可以在该方法中对所有数据进行修改 并将修改后的数据返回即可
            }
        });

        System.out.println(list);
    }

    /*
     * E get(int index)：返回[index]位置的元素
     * List subList(int fromIndex, int toIndex)：返回[fromIndex, toIndex)范围的元素

     * int indexOf(Object obj)：查询obj在列表中的位置，如果有重复，返回第1个
     * int lastIndexOf(Object obj)：查询obj在列表中的位置，如果有重复，返回最后1个
     */
    @Test
    public void test3(){
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

        System.out.println(list.get(2));
        System.out.println(list.subList(1,4));
    }
}

5.list的实现 ArrayList

ArrayList第一次添加元素时扩容长度为10

下次扩容为原来的1.5被并copy进来

也可以初始化数组的长度

import org.junit.Test;

import java.util.ArrayList;

/*
    List的实现类： ArrayList

    说明：
        1.ArrayList的底层是一个Object[]

    [面试题]ArrayList的底实现？
        当我们通过ArrayList的空参构造器创建对象时底层会创建一个长度为0的Object[]。
        当我们第一次向该对象中添加元素时底层会扩容 扩容的长度为10(原来的长度是0).
        当我们向该对象中添加第11个元素时底层会再次扩容扩容为原来的1.5倍。并且将原来的数组中的元素
            copy到当前数组中。
 */
public class ArrayListTest {

    @Test
    public void test(){
        //创建ArrayList对象
        ArrayList list = new ArrayList();//底层创建了一个空数组-长度为0
        list.add("a");//在第一次添加数据时底层会进行扩容-数组的长度为10
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("b");

        System.out.println(list);
    }


    @Test
    public void test2(){
        ArrayList list = new ArrayList(100);//可以指定初始化时的数组的长度。
    }

}