String、包装数据类型、集合框架

晴ber

于 2024-03-29 20:51:34 发布

阅读量945

点赞数 16

文章标签： java 开发语言 ide

本文链接：https://blog.csdn.net/qq_70347821/article/details/137155776

版权

本文详细介绍了Java中的String对象特性，如常量池、equals()方法等，对比了String、StringBuffer和StringBuilder的异同，探讨了包装数据类型的应用以及ArrayList、LinkedList和Set、Map等集合框架的区别和操作方法。

摘要由CSDN通过智能技术生成

一、String

@Test
public void test2() {
    // "abc"双引号括起来的字符串：常量字符串，他也是一个对象
    // 如果常量池里面没有这个字符串对象，java就帮你在常量池里面new一个"abc"字符串对象。
    // 如果常量池里面有这个字符串，就把这个字符串的地址赋给这个变量。
    String str1 = "abc";
    String str2 = "abc";
    String str3 = new String("abc");

    //==比较的是变量指向的对象的地址值
    System.out.println(str1 == str2);//true
    System.out.println(str3 == str2);//false
    System.out.println(str3 == str1);//false

    // 比较字符串的内容是不是相等使用equals()
    // 表str1这个字符串和str2这个字符串的内容是不是相等
    System.out.println(str1.equals(str2));//true
    System.out.println(str1.equals(str3));//true
    System.out.println(str2.equals(str3));//true
}

1、获取

int length() 返回此字符串的长度。
char charAt(int index) 返回指定索引处的 char 值。
int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
int indexOf(int ch,int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索
int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。
int indexOf(String str,int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始,
int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引。
int lastIndexOf(int ch,int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索
int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引。
int lastIndexOf(String str,int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

2、判断

boolean equals(Object anObject) 将此字符串与指定的对象比较。
boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。
boolean contains(CharSequence s) 当且仅当此字符串包含指定的 char 值序列时，返回 true。
boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始。
boolean startsWith(String prefix,int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束。
boolean isEmpty() 当且仅当 length() 为0 时返回 true.

3、转换

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

4,替换

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

5,切割

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

6.子串，获取字符串中的一部分

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

7,转换，去除空格，比较

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

@Test
public void test3() {

    String str = "java adfnka";
    System.out.println(str.length());
    char[] chars = str.toCharArray();
    char ch = str.charAt(5);
    System.out.println(ch);
    System.out.println(str.indexOf('a'));
    System.out.println(str.indexOf('f'));
    System.out.println(str.indexOf('a', 5));

    System.out.println(str.startsWith("java"));
    System.out.println(str.startsWith("va", 3));
}

@Test
public void test5() {
    char[] array = {'j','a','v','a',' ','A','n','d'};
    String str = new String(array);
    System.out.println(str);//java And
    char[] chars = str.toCharArray();
    System.out.println(chars);//java And
    for (char aChar : chars) {
        System.out.println(aChar);
    }
}

@Test
public void test4() {
    String str = "java AndroidA";
    String newStr = str.replace('A', 'b');
    System.out.println(str);
    System.out.println(newStr);
}

@Test
public void test6() {
    String str = "java AndroidA";
    //subtree  subtring
    System.out.println(str.substring(5));//AndroidA
    System.out.println(str.substring(5,8));//And
}

@Test
public void test88() {
    String str = "Java:Andorid:PHP:Python";
    String[] array = str.split(":");
    //System.out.println(array);
    System.out.println(Arrays.toString(array));//[Java, Andorid, PHP, Python]
}

二、String、StringBuffer、StringBuilder异同点

相同点：都是final类，都不能被继承。

不同点：

1、String长度是不可改变的，StringBuffer、StringBuilder长度是可变的。

每个变量拼接时候会new一个对象，四个变量拼接就要构造三个String对象，其中有两个是临时对象会被当成垃圾回收

常量字符串的拼接，编译器会做优化，使用String就可以

2、StringBuffer是线程安全（需要加锁，效率低)、StringBuilder是线程不安全（没有加锁，效率高）。

如果对代码加锁，就可以实现每次只有一个用户能进入这段代码，当执行完了之后，释放这个锁，另一个用户才能进来。

@Test
public void test10() {
    String str1 = "java";
    String str2 = "php";
    String str3 = "python";
    //会浪费空间
    String str4 = str1 + str2 + str3;
    System.out.println(str4);//javaphppythonjavaphppython

    StringBuilder builder = new StringBuilder("C");
    builder.append(str1);
    builder.append(str2);
    builder.append(str3);
    builder.append(str1).append(str2).append(str3);
    String str = builder.toString();
    System.out.println(str);//Cjavaphppythonjavaphppython

    StringBuffer buffer = new StringBuffer("b");
    //链式编程
    buffer.append(str1).append(str2).append(str3);
    String str5 = buffer.toString();
    System.out.println(str5);//bjavaphppythonjavaphppython

}

三、包装数据类型

Java是纯面向对象语言，int、double都是基本数据类型，包装数据类型是对基本数据类型的封装。

int Integer

char Character

double Double

long Long

short Short

boolean Boolean

byte Byte

float Float

Test
public void test11() {

    //public static final int   MAX_VALUE = 0x7fffffff;
    System.out.println(Integer.MAX_VALUE);

    //自动装箱和自动拆箱
    Integer integer1 = new Integer(4);
    System.out.println(integer1);//4
    Integer integer2 = 4;//自动装箱
    System.out.println(integer2);//4
    //int i = integer2.intValue();
    int num1 = integer2;//自动拆箱
    System.out.println(num1);//4

    Integer integer = 3;
    int num2 = integer + 4;
    integer = integer + 5;
}

//包装数据类型和字符串之间的转换
@Test
public void test12() {
    //把字符串转换成基本数据类型（从网页的输入框中得到的都是字符串）
    String str1 = "23";
    int i = Integer.parseInt(str1);
    i = i + 1;
    System.out.println(i);
    System.out.println(Double.parseDouble("3.14"));
}

包装数据类型最主要使用：包装数据类型和字符串之间的转换

1、把基本数据类型转换成字符串

(1) 基本数据类型+"" : String str = 12 + ""; // "12"

(2) 基本数据类型的包装类.toString()

String str1 = Integer.toString(3);

String str2 = Double.toString(3.14);

2、把字符串转换成基本数据类型（从网页的输入框中得到的都是字符串）

(1) Integer.parseInt(String str); // "23"

Double.parseDouble(String str); //"3.14"

Boolean.parseBoolean(String str);//"true"

XXXX.parseXXXX(String str);

(2) new对象： Integer integer = new Integer(String str);

Integer interger = new Integer("4");

int i = integer.intValue();

四、集合框架

一、简介

Java集合框架位于java.util包中

Collection是Set和List的父类，Collections是工具类，提供了对集合进行排序、遍历等多种算法的实现。

ArrayList: 有序(放进去顺序和拿出来顺序一致)，可重复

HashSet: 无序(放进去顺序和拿出来顺序不一定一致)，不可重复

在Java中，List和Set都是集合框架的接口，它们有以下区别：

List：

List是有序集合，可以按照元素插入顺序来访问和存储元素。
List允许重复元素。
List接口的常见实现类包括ArrayList、LinkedList和Vector。

Set：

Set是不允许重复元素的集合，每个元素在Set中是唯一的。
Set不保证元素的顺序，即元素存储的顺序可能与插入顺序不同。
Set接口的常见实现类包括HashSet、LinkedHashSet和TreeSet。

@Test
public void test1() {
    //数组长度固定，要操作下标，容易出现数组下标越界异常
    Student[] arry = new Student[3];

    ArrayList<Student> list = new ArrayList();
    Student student1 = new Student();
    Student student2 = new Student();
    Student student3 = new Student();
    Student student4 = new Student();

    list.add(student1);
    list.add(student2);
    list.add(student3);
    list.add(student4);

    //list.for
    for (Student student : list) {
        System.out.println(student);
    }
}

@Test
public void test2() {
    String[] arry = new String[3];

    //List: 有序可重复
    //有序：放到集合里面的顺序和拿出来的顺序一样
    //ArrayList<String> list = new ArrayList<>();
    List<String> list = new ArrayList<>();
    list.add("java");
    list.add("H1");
    list.add("H5");
    list.add("aaa");
    for (String sting : list) {
        System.out.println(sting);
    }
    System.out.println(list);

    //Set:无序不重复
    //无序：放到集合里面的顺序和拿出来顺序可能不一致
    //HashSet<String> set = new HashSet<>();
    Set<String> set = new HashSet<>();
    set.add("java");
    set.add("H1");
    set.add("H5");
    set.add("aa");
    for (String string : set) {
        System.out.println(string);
    }
    System.out.println(set);
}

二、ArrayList和LinkedList区别

ArrayList和LinkedList的大致区别如下:

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。

2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

LinkedList linkedList = new LinkedList();
linkedList.addFirst("A");
linkedList.removeFirst();
linkedList.addLast("B");
linkedList.removeLast();

三、队列

Queue先进先出 FIFO Firt In First Out

LinkedList linkedList = new LinkedList();
linkedList.addLast("A");
linkedList.addLast("B");
linkedList.addLast("C");
linkedList.removeFirst();

四、Map

接口 Map key,value

Map接口

1、Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储。

2、Map中的集合，元素是成对存在的。每个元素由键与值两部分组成，通过键可以找对所对应的值。

3、Collection中的集合称为单列集合，Map中的集合称为双列集合。

4、需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

5、Map中常用的集合为HashMap集合、LinkedHashMap集合。

@Test
public void test3() {
    HashMap<String, String> map = new HashMap<>();
    map.put("cn", "中国");
    map.put("us", "美国");
    map.put("uk", "英国");
    Set<Map.Entry<String, String>> set = map.entrySet();
    for (Map.Entry<String, String> entry : set) {
        System.out.println(entry.getKey() + " : " + entry.getValue());
    }
    System.out.println("----------");
    String country = map.get("cn");
    System.out.println(country);
    System.out.println("----------");
    Set<String> keySet = map.keySet();
    for (String key : keySet) {
        System.out.println(key + " : " + map.get(key));
    }
}

@Test
public void test13() {
    //Set遍历的时候，可以使用增强的for循环，也可以使用迭代器遍历
    HashMap<String, String> map = new HashMap<>();
    map.put("cn", "中国");
    map.put("us", "美国");
    map.put("uk", "英国");
    Set<String> keySet = map.keySet();
    Iterator<String> iterator1 = keySet.iterator();
    while (iterator1.hasNext()) {
        String key = iterator1.next();
        System.out.println(key + " : " + map.get(key));
    }
    System.out.println("-----------------");
    Set<Map.Entry<String, String>> entrySet = map.entrySet();
    Iterator<Map.Entry<String, String>> iterator2 = entrySet.iterator();
    while (iterator2.hasNext()) {
        Map.Entry<String, String> entry = iterator2.next();
        System.out.println(entry.getKey() + " : " + entry.getValue());
    }
}

晴ber

关注

16
点赞
踩
17

收藏

觉得还不错? 一键收藏
1
评论
String、包装数据类型、集合框架

Java集合框架位于java.util包中Collection是Set和List的父类，Collections是工具类，提供了对集合进行排序、遍历等多种算法的实现。ArrayList: 有序(放进去顺序和拿出来顺序一致)，可重复HashSet: 无序(放进去顺序和拿出来顺序不一定一致)，不可重复在Java中，List和Set都是集合框架的接口，它们有以下区别：List是有序集合，可以按照元素插入顺序来访问和存储元素。List允许重复元素。
复制链接

扫一扫