Java容器——数组array(字符串string)、集合list/set/map

目录

数据结构：

Java容器：

数组（Array）

1. 存储的特点：

2. 声明与初始化：一维、二维数组

3. 操作数组的方法（java.util包下）

4. 常见异常

String：相当于特殊数组 final char[] value用于存储字符串数据

1. 特点

2. 常用方法：

3.String与其它结构的转换     

4. String、StringBuffer、StringBuilder三者的对比

5. StringBuffer、StringBuilder中的常用方法

集合：单列集合Collection接口、双列集合Map接口

Collection接口：单列集合，用来存储一个一个的对象

1. List接口：存储序的、可重复的数据。  -->“动态”数组

1.1  ArrayList、LinkedList、Vector

1.2 常用方法

2. Set接口：存储无序的、不可重复的数据   本质是map -->数学“集合”

2.1 HashSet、LinkedHashSet、TreeSet

Map:双列数据，存储key-value对的数据   ---类似于函数：y = f(x)

1. HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

2. 键值 存储结构：

3.常用方法

4.读取配置文件.properties:(使用Classloader加载src目录下的配置文件(.properties))

---

数据结构：

1.数据与数据之间的逻辑关系：集合、一对一、一对多、多对多
2.数据的存储结构：

• 线性表：顺序表（比如：数组）、链表、栈、队列
• 树形结构：二叉树
• 图形结构：

Java容器：

集合、数组都是对多个数据进行内存层面存储操作的结构，简称Java容器。

数组（Array）

1. 存储的特点：

1. 定义和初始化后，元素数据类型和数组长度不可更改
2. 元素存储是有序的、可重复。有序指的存储位置
3. 适用于查找操作，不便于增、删、插入操作
4. 无现有方法/属性  获得数组中实际元素的个数
5. 属性：array.length ，引用:  array[index]

2. 声明与初始化：一维、二维数组

        int[] ids;//声明
        //1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
        ids = new int[]{1001,1002,1003,1004};
        //1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
        String[] names = new String[5];

        int[] arr = new int[]{1,2,3};//一维数组
        //静态初始化
        int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
        //动态初始化1
        String[][] arr2 = new String[3][2];
        //动态初始化2
        String[][] arr3 = new String[3][];
        //也是正确的写法：
        int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};

3. 操作数组的方法（java.util包下）

1. boolean equals(int[] a,int[] b):判断两个数组是否相等。
2. String toString(int[] a):输出数组信息。
3. void fill(int[] a,int val):将指定值填充到数组之中。
4. void sort(int[] a):对数组进行排序。

4. 常见异常

1. 数组角标越界异常：ArrayIndexOutOfBoundsException
2. 空指针异常：NullPointerException

String：相当于特殊数组 final char[] value用于存储字符串数据

1. 特点

1. String声明为final的，不可被继承，不可更改
2. 实现了Serializable接口：表示字符串是支持序列化的。
   实现了Comparable接口：表示String可以比较大小
3. 相同字符串在字符串常量池中内存地址相同，常量池不会重复存储相同内容
4. 对字符串任何更改操作时，都需要 重写指定内存区域 赋值
5. 字符串拼接的结果 调用intern()方法，返回值就在常量池中
6. String实例化方式：方式一：通过字面量定义的方式  String s1 = "javaEE";
                     方式二：通过new + 构造器的方式 String s = new String("abc")
     方式二创建对象，在内存中创建了几个对象？
           两个:一个是堆空间中new结构，另一个是char[]对应的常量池中的数据："abc"

2. 常用方法：

int length()：返回字符串的长度： return value.length
char charAt(int index)： 返回某索引处的字符return value[index]
void deleteCharAt(int index): 删除某索引处的字符
boolean isEmpty()：判断是否是空字符串：return value.length == 0
String toLowerCase()：使用默认语言环境，将 String 中的所字符转换为小写
String toUpperCase()：使用默认语言环境，将 String 中的所字符转换为大写
String trim()：返回字符串的副本，忽略前导空白和尾部空白
boolean equals(Object obj)：比较字符串的内容是否相同
boolean equalsIgnoreCase(String anotherString)：与equals方法类似，忽略大小写
String concat(String str)：将指定字符串连接到此字符串的结尾。 等价于用“+”
int compareTo(String anotherString)：比较两个字符串的大小—可用于字符串排序
String substring(int beginIndex)：返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个子字符串。
String substring(int beginIndex, int endIndex) ：返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex(不包含)的一个子字符串。  左闭右开

boolean endsWith(String suffix)：测试此字符串是否以指定的后缀结束
boolean startsWith(String prefix)：测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始

boolean contains(CharSequence s)：当且仅当此字符串包含指定的 char 值序列时，返回 true
int indexOf(String str)：返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex)：返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
int lastIndexOf(String str)：返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex)：返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索

注：indexOf和lastIndexOf方法如果未找到都是返回-1

替换：
String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所 oldChar 得到的。
String replace(CharSequence target, CharSequence replacement)：使用指定的字面值替换序列替换此字符串所匹配字面值目标序列的子字符串。
String replaceAll(String regex, String replacement)：使用给定的 replacement 替换此字符串所匹配给定的正则表达式的子字符串。
String replaceFirst(String regex, String replacement)：使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
匹配:
boolean matches(String regex)：告知此字符串是否匹配给定的正则表达式。
切片：
String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。
String[] split(String regex, int limit)：根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

3.String与其它结构的转换     

3.1 与基本数据类型、包装类之间的转换
    String --> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str)
        int num = Integer.parseInt(str1);
    基本数据类型、包装类 --> String:调用String重载的valueOf(xxx)
        String str2 = String.valueOf(num);

3.2 与字符数组之间的转换
String --> char[]:调用String的toCharArray()
char[] --> String:调用String的构造器 new String（char[]）

3.3 与StringBuffer、StringBuilder之间的转换
String -->StringBuffer、StringBuilder:调用StringBuffer、StringBuilder构造器
StringBuffer、StringBuilder -->String:①调用String构造器；
                                                           ②StringBuffer、StringBuilder的toString()

4. String、StringBuffer、StringBuilder三者的对比

String:不可变的字符序列；底层使用char[]存储
StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储
执行效率：从高到低排列：StringBuilder > StringBuffer > String

StringBuffer sb1 = new StringBuffer();
//底层创建了一个长度是16的数组。扩容为原来容量的2倍 + 2
  建议使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)  指定容量避免扩容

5. StringBuffer、StringBuilder中的常用方法

增：append(xxx)
删：delete(int start,int end)
改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
查：charAt(int n )
插：insert(int offset, xxx)
长度：length();
遍历：for() + charAt() / toString()

集合：单列集合Collection接口、双列集合Map接口

存储的优点：解决数组存储数据方面的弊端。

Collection接口：单列集合，用来存储一个一个的对象

jdk7中的ArrayList的对象的创建类似于单例的饿汉式，声明时创建

jdk8中的ArrayList的对象的创建类似于单例的懒汉式，操作时创建，延迟了数组的创建，节省内存。

Collection接口常用方法：collection接口的对象.方法名（）
Collection coll = new Arraylist();
add(Object obj)添加元素,addAll(Collection coll)添加集合中的所有元素,
size()集合内元素数,isEmpty()集合是否为空,clear()清空集合元素;
contains(Object obj),containsAll(Collection coll),remove(Object obj),removeAll(Collection coll),retainsAll(Collection coll),equals(Object obj);
hasCode()返回对象哈希值,toArray()集合转化成数组,iterator();
Arrays.asList(数组)数组转化集合

1. List接口：存储序的、可重复的数据。  -->“动态”数组

要求：添加的对象，所在的类要重写equals()方法

1.1  ArrayList、LinkedList、Vector

*  ArrayList：作为List接口的主要实现类；线程不安全的，效率高；
        底层使用Object[] elementData存储 。底层初始长度为10，扩容1.5倍，另辟空间，复制过去
        建议使用带参的构造器：ArrayList list = new ArrayList(int capacity);//确定所需容量
*  LinkedList：对于频繁的插入、删除操作，使用此类效率比ArrayList高,但不便于查找；
        底层使用双向链表存储
              LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值为null
              list.add(123);//将123封装到Node中，创建了Node对象。
              其中，Node定义为：体现了LinkedList的双向链表的说法
              private static class Node {
                    E item;
                    Node next;
                    Node prev;

                    Node(Node prev, E element, Node next) {
                    this.item = element;
                    this.next = next;
                    this.prev = prev;
                    }
                }

*  Vector：作为List接口的古老实现类；线程安全的，效率低；
        底层使用Object[] elementData存储。底层初始长度为10，扩容2倍

1.2 常用方法

增：void add(Object obj)， boolean addall(List list)
删：Object remove(int index) / remove(Object obj)   :返回删除的元素
改：Object set(int index, Object ele)
查：get(int index)
插：add(int index, Object ele)
返回首次、末次出现的位置：int indexOf(Object obj)，int LastIndexOf(Object obj)
左闭右开子列表: int subList(int fromIndex, int toIndex)
长度：size()
遍历：① Iterator迭代器方式
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){  //hasNext():判断是否还下一个元素
                System.out.println(iterator.next());//iterator.next()：指针下移
        }

     ② 增强for循环（foreach循环）
        for(Object obj:list){
            System.out.println(obj);
        }
     for(集合元素的类型 局部变量 : 集合对象) {对obj操作} 
        将集合对象的值赋给obj(局部变量)，对obj的操作不影响原集合，内部仍然调用了迭代器。
     ③ 普通的循环  用get()方法
        for(int i=0; i             System.out.println(list.get(i));
        }

2. Set接口：存储无序的、不可重复的数据   本质是map -->数学“集合”

1. set中元素根据数据的哈希值决定底层数组位置（无序），位置判断以元素的哈希值为准，意味着此位置上可存在一个或多个数据(以链表形式存在)
2. 元素按照equals()判断是否可以添加，相同的元素只能添加一个（不可重复性）。

jdk 7 :元素a放到数组中，指向原来的元素。HashSet底层：数组+链表的结构。（前提：jdk7)
jdk 8 :原来的元素在数组中，指向元素a
总结：链表 七上八下  

要求：向Set(主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写hashCode()和equals()，并保持所需属性一致

2.1 HashSet、LinkedHashSet、TreeSet

HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值
LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历
              在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。               对于频繁的遍历操作，LinkedHashSet效率高于HashSet.
TreeSet：可以照添加对象的指定属性，进行排序。
          1.向TreeSet中添加的数据，要求是相同类的对象。
          2.两种排序方式：自然排序（数据类class实现Comparable接口 ，重写compareto()方法）
                                      定制排序（创建Comparator对象，重写compare()方法）
        比较两个对象是否相同的标准为：compareTo()返回0或 .compare()返回0.不再是equals().

Map:双列数据，存储key-value对的数据   ---类似于函数：y = f(x)

1. HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
            HashMap的底层：数组+链表  （jdk7及之前)
                                         数组+链表+红黑树 （jdk 8)
     底层初始长度为16数组，当超出临界值12(且要存放的位置非空)时，扩容2倍，原数据复制过来
LinkedHashMap:保证在遍历map元素时，可以照添加的顺序实现遍历。
             在原的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
                     对于频繁的遍历操作，此类执行效率高于HashMap。
TreeMap:保证照添加的key-value对进行排序，实现key的排序遍历。
               此时考虑key的自然排序或定制排序
             TreeMap底层使用红黑树
Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
Properties:常用来处理配置文件。key和value都是String类型

2. 键值 存储结构：

>Map中的key:无序的、不可重复的，使用Set存储所的key
                ---> key所在的类要重写equals()和hashCode() （以HashMap为例)
>Map中的value:无序的、可重复的，使用Collection存储所的value
                --->value所在的类要重写equals()
> 一个键值对：key-value构成了一个Entry对象。使用Set存储所的entry
                >Map中的entry:无序的、不可重复的，

3.常用方法

* 添加：Object put(Object key,Object value) / void putAll(Map m)  添加所有
* 删除：Object remove(Object key) / clear():清空map数据，将map.size=0  ！=  map=Null
* 修改：put(Object key,Object value)
* 查询：Object get(Object key)  
        / boolean containsKey(Object key)  /boolean containsValue(Object value) :是否包含该元素
* 长度：int size()
* 遍历：Set keySet() / Collection values()
        / Set entrySet()+entry.getKey()+entry.getValue()        强转后才可调用子类方法
map无序  -> 无插入操作   

4.读取配置文件.properties:(使用Classloader加载src目录下的配置文件(.properties))

@Test
    public void test2() throws Exception {

        Properties pros =  new Properties();
        //此时的文件默认在当前的module下。
        //读取配置文件的方式一：
//        FileInputStream fis = new FileInputStream("jdbc.properties");
//        FileInputStream fis = new FileInputStream("src\\jdbc1.properties");
//        pros.load(fis);

        //读取配置文件的方式二：使用ClassLoader
        //配置文件默认识别为：当前module的src下
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
        pros.load(is);

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        System.out.println("user = " + user + ",password = " + password);
    }