java基础（4）---引用数据类型（数组、字符串、集合）

 

一、数组

1、格式：int[] nums;

1. 数据类型[] 数组名称;

2. 数据类型 数组名称[]; (不太推荐)

 

2、 动态初始化：new int[4]

　　数据类型[] 数组名称 = new 数据类型[数组长度]

　　

默认值：

3、静态初始化：

int[] nums = new int[] {1,2,3,4} /  int[] nums = {1,2,3,4}

 

 4、访问数组元素：数组名[index]

　　直接访问数组名，返回 [I@…… ,其中[表明是数组，I表示Int类型，@后面是地址。

 访问数组中元素: 从0开始，且索引没有负数。

改变数组元素： 数组名[index] = 赋值

5、方法： nums.length

　　获取数组长度：数组名称.length

 代码示例：

// 两种先声明后创建的方式（声明和创建都有2种方式）
int[] list1;
int list2[];
list1 = new int[4];
list2 = new int[] {11,22,33,44};
 
// 第一种：声明的同时创建（3种方式）
int[] list3 = new int[4];
int[] list4 = new int[] {11,22,33,44};
int[] list5 = {11,22,33,44};
 
// 第二种：声明的同时创建（3种方式）
int list6[] = new int[4];
int list7[] = new int[] {11,22,33,44};
int list8[] = {11,22,33,44};

6、多维数组：int [][] = new int[4][4];

7、数组的排序：Arrays.sort(a);

import java.util.Arrays;
int[] a = { 12,3,19,2,10,13,9};
Arrays.sort(a);  // a为排序之后的值

 

8、Arrays类：

import java.util.Arrays;
import java.util.Random;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] arr = new int[10];
        //将数组元素都设为9
        Arrays.fill(arr, 9);
        System.out.println("fill:" + Arrays.toString(arr));
        Random random = new Random();
        for (int i = 0; i < arr.length; i++) {
            //使用100以内的随机数赋值数组
            arr[i] = random.nextInt(101);
        }
        //重新赋值后的数组
        System.out.println("重新赋值：" + Arrays.toString(arr));
        //将索引为5的元素设为50
        arr[5] = 50;
        //排序
        Arrays.sort(arr);
        //排序后的数组
        System.out.println("sort排序后：" + Arrays.toString(arr));
        //查找50的位置
        int i = Arrays.binarySearch(arr, 50);
        System.out.println("值为50的元素索引："+i);
        //复制一份新数组
        int[] newArr = Arrays.copyOf(arr, arr.length);
        //比较
        System.out.println("equals:"+Arrays.equals(arr, newArr));
    }
}

 

二、字符串（java.lang.String对象）

 1、创建字符串：

①String str1 = new String("a"); //不检查字符串常量池的

 

②String str2 = "bb"; //检查字符串常量池的

 字符串池：

 2、字符串不可变：

　　一旦觉得字符串变了的话，一定是创建了新的字符串，而不是改变了字符串。

 

 

 

 3、字符串比较方法：equals

常量尽量写在前面：

  

 　　equals不忽略大小写，equalsIgnoreCase忽略大小写。

 4、字符串替换方法：replace

 5、字符串切分：split

　　

 　　如果一定要使用英文句点，那就使用 " \. "

 

 6、字符串长度：int len = s.length();

字符串索引：转成数组访问 s.toCharArray();

三、StringBuffer和StringBuilder

面试官:String、StringBuffer、StringBuilder有什么区别?

https://www.cnblogs.com/songsongblue/p/9798651.html

因为String的不可变性，所以例如拼接字符串时候会产生很多无用的中间对象，如果频繁的进行这样的操作对性能有所影响。

StringBuffer就是为了解决大量拼接字符串时产生很多中间对象问题而提供的一个类，提供append和add方法，可以将字符串添加到已有序列的末尾或指定位置，它的本质是一个线程安全的可修改的字符序列，把所有修改数据的方法都加上了synchronized。但是保证了线程安全是需要性能的代价的。

在很多情况下我们的字符串拼接操作不需要线程安全，这时候StringBuilder登场了，StringBuilder是JDK1.5发布的，它和StringBuffer本质上没什么区别，就是去掉了保证线程安全的那部分，减少了开销。

StringBuilder：

一、创建Stringbuilder对象
StringBuilder strB = new StringBuilder();

1、append(String str)/append(Char c)：字符串连接
System.out.println("StringBuilder:"+strB.append("ch").append("111").append('c'));
//return "StringBuilder:ch111c"

2、toString()：返回一个与构建起或缓冲器内容相同的字符串
System.out.println("String:"+strB.toString());
//return "String:ch111c"

3、appendcodePoint(int cp)：追加一个代码点，并将其转换为一个或两个代码单元并返回this
System.out.println("StringBuilder.appendCodePoint:"+strB.appendCodePoint(2));
//return "StringBuilder.appendCodePoint:ch111c"

4、setCharAt(int i, char c)：将第 i 个代码单元设置为 c（可以理解为替换）
strB.setCharAt(2, 'd');
System.out.println("StringBuilder.setCharAt:" + strB);
//return "StringBuilder.setCharAt:chd11c"

5、insert(int offset, String str) / insert(int offset, Char c)：在指定位置之前插入字符(串)
System.out.println("StringBuilder.insertString:"+ strB.insert(2, "LS"));
//return "StringBuilder.insertString:chLSd11c"
System.out.println("StringBuilder.insertChar:"+ strB.insert(2, 'L'));
//return "StringBuilder.insertChar:chLLSd11c"

6、delete(int startIndex,int endIndex)：删除起始位置（含）到结尾位置（不含）之间的字符串
System.out.println("StringBuilder.delete:"+ strB.delete(2, 4));
//return "StringBuilder.delete:chSd11c"

 

总结：

1、在字符串不经常发生变化的业务场景优先使用String(代码更清晰简洁)。如常量的声明，少量的字符串操作(拼接，删除等)。

2、在单线程情况下，如有大量的字符串操作情况，应该使用StringBuilder来操作字符串。不能使用String"+"来拼接而是使用，避免产生大量无用的中间对象，耗费空间且执行效率低下（新建对象、回收对象花费大量时间）。如JSON的封装等。

3、在多线程情况下，如有大量的字符串操作情况，应该使用StringBuffer。如HTTP参数解析和封装等。

　　

四、集合（长度可变）

1、ArrayList:

import java.util.ArrayList;

创建一个集合：

 

 使用集合：add、get、size

 　　

 集合存储基本类型

 

 

为什么要提供包装类呢？？？

一是为了在各种类型间转化，通过各种方法的调用。否则 你无法直接通过变量转化。

 集合存储自定义类型对象：

 2、HashSet 

https://blog.csdn.net/refusing/article/details/80617783

HashSet简单的理解就是HashSet对象中不能存储相同的数据，存储数据时是无序的。

• 它存储唯一元素并允许空值
• 它由HashMap支持
• 它不保持插入顺序
• 它不是线程安全的

（1）创建：

（2）方法：

//只有当元素尚未存在于集合中时才会添加元素。如果成功添加了元素，则该方法返回true，否则返回false。
hashset.add("String Added");

//contains方法的目的是检查给定HashSet中是否存在元素。如果找到该元素，则返回true，否则返回false。
hashset.contains("String Added");

//r如果存在，remove方法将从集合中删除指定的元素。如果集合包含指定的元素，则此方法返回true。
hashset.remove("String Added");

//从集合中删除所有项目时,clear()方法
hashset.clear();

//size()识别HashSet中存在的元素数量
hashset.size()

//isEmpty（）确定HashSet的给定实例是否为空。如果集合不包含任何元素，则此方法返回true
hashset.isEmpty();

// Iterator（）返回Set中元素的迭代器。这些元素没有特定的顺序访问，Iterator是fail-fast的。
public void whenIteratingHashSet_shouldIterateHashSet() {
    Set<String> hashset = new HashSet<>();
    hashset.add("First");
    hashset.add("Second");
    hashset.add("Third");
    Iterator<String> itr = hashset.iterator();
    while(itr.hasNext()){
        System.out.println(itr.next());
    }
}

（3） 遍历：

法一：

 法二：

 

（4）整型：

 3、HashMap

• HashMap是一个散列表，它存储的是键值对（key-value）映射；
• HashMap的实现不是同步的，线程不安全，但是效率高；
• HashMap允许null键和null值，是基于哈希表的Map接口实现；
• 哈希表的作用是用来保证键的唯一性；

方法：

（1） 插入键值对数据： put( key, value)

（2）根据键值获取键值对值数据： get(Object key)

（3）获取Map中键值对的个数： size()

（4）判断Map集合中是否包含键为key的键值对 ：containsKey(Object key)

（5）判断Map集合中是否包含值为value的键值对： containsValue(Object value)

（6）判断Map集合中是否没有任何键值对：isEmpty()

（7）清空Map集合中所有的键值对： clear()

（8）根据键值删除Map中键值对：remove(Object key)

示例：

import java.util.HashMap;
import java.util.Map;

public class Demo01 {

    public static void main(String[] args) {
        // 声明HashMap对象
        Map<String,Integer> map= new HashMap<>();

        //添加数据
        map.put("ZhangYi",98);
        map.put("WangEr",99);
        map.put("ZhangShan",89);
        map.put("Lisi",92);

        //根据键值对键值获取数据‘’
        int value=map.get("Lisi");
        System.out.println("kay:Lisi And value:"+value);

        //获取Map中键值对的个数
        int size=map.size();
        System.out.println("map 中的键值对个数为："+size);

        //判断Map集合中是否包含键为key的键值对
        boolean b1=map.containsKey("LiSI");
        boolean b2=map.containsKey("Lisi");
        System.out.println("是否包含键值为LiSI的键值对数据："+b1);
        System.out.println("是否包含键值为Lisi的键值对数据："+b2);

        //判断Map集合中是否包含值为value的键值对
        boolean b3=map.containsValue(99);
        boolean b4=map.containsValue(100);
        System.out.println("是否包含值为99的键值对数据："+b3);
        System.out.println("是否包含值为100的键值对数据："+b4);

        //判断Map集合中是否没有任何键值对

        boolean b5=map.isEmpty();
        System.out.println("map中键值对数据是否为空："+b5);

        //根据键值删除Map中键值对
        int value2=map.remove("Lisi");
        System.out.println("删除了键为Lisi的键值对数据，其值为："+value2);

        boolean b6=map.containsKey("Lisi");
        System.out.println("是否包含键值为Lisi的键值对数据："+b6);

        //清空Map集合中所有的键值对
        map.clear();
        boolean b7=map.isEmpty();
        System.out.println("map中键值对数据是否为空："+b7);

    }
}

遍历：

（1）将Map中所有的键装到Set集合中返回-----键

Set<K> set=map. keySet() 

（2）返回集合中所有的value的值的集合-----值

Collection<V> c=map.values()

（3）将每个键值对封装到一个个Entry对象中,再把所有Entry的对象封装到Set集合中返回----键值对

Set<Map.Entry<K,V>> entrys=map.entrySet()

 示例：

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo02 {
    public static void main(String[] args) {
        // 声明HashMap对象
        Map<String,Integer> map= new HashMap<>();

        //添加数据
        map.put("ZhangYi",98);
        map.put("WangEr",99);
        map.put("ZhangShan",89);
        map.put("Lisi",92);

        //（1）将Map中所有的键装到Set集合中返回
        Set<String> keys=map.keySet();
        for(String key:keys){
            int value=map.get(key);
            System.out.println("key:"+key+"  and  value:"+value);
        }

        //（2）返回集合中所有的value的值的集合
        Collection<Integer> values=map.values();
        for(int value:values){
            System.out.print(value+"   ");
        }
        System.out.println();

        //（3）将每个键值对封装到一个个Entry对象中,再把所有Entry的对象封装到Set集合中返回
        Set<Map.Entry<String,Integer>> entries=map.entrySet();
        for(Map.Entry<String,Integer> entry :entries){
            String key=entry.getKey();
            int value=entry.getValue();
            System.out.println("key:"+key+"  and  value:"+value);
        }
    }

}