黑马程序员_java之字符串String及集合

------- android培训、 java培训、期待与您交流！ ----------

常见关于String面试题说法:

String s1 = "abc";

String s2 = new String("abc");

s1是一个类型变量，"abc"是一个对象。

字符串最大特点是一旦被初始化就不可以被改变。

S1在内存中有一个对象，S2在内存中有两个对象。

String类复写了Object类中equals方法，该方法用于判断字符串是否相同。

常见对String操作：

1，获取。

       1.1字符串中的包含的字符数，也就是字符串的长度。

              intlength():获取长度。

       1.2根据位置获取位置上某个字符。

              charcharAt(int index):

       1.3根据字符获取该字符在字符串中位置。

              intindexOf(int ch):返回的是ch在字符串中第一次出现的位置。

              intindexOf(int ch, int fromIndex) :从fromIndex指定位置开始，获取ch在字符串中出现的位置。 

              intindexOf(String str):返回的是str在字符串中第一次出现的位置。

              intindexOf(String str, int fromIndex) :从fromIndex指定位置开始，获取str在字符串中出现的位置。

              intlastIndexOf(int ch) ：

 2，判断。

       2.1字符串中是否包含某一个子串。

              booleancontains(str):

              特殊之处：indexOf(str):可以索引str第一次出现位置，如果返回-1.表示该str不在字符串中存在。

                            所以，也可以用于对指定判断是否包含。

                                if(str.indexOf("aa")!=-1) 

                               而且该方法即可以判断，有可以获取出现的位置。 

            2.2字符中是否有内容。

              booleanisEmpty(): 原理就是判断长度是否为0.

       2.3字符串是否是以指定内容开头。

              booleanstartsWith(str);

       2.4字符串是否是以指定内容结尾。

              booleanendsWith(str);

       2.5判断字符串内容是否相同。复写了Object类中的equals方法。

              booleanequals(str);

       2.6判断内容是否相同，并忽略大小写。

              booleanequalsIgnoreCase();     

3，转换。

       3.1将字符数组转成字符串。

              构造函数：String(char[])

                              String(char[],offset,count):将字符数组中的一部分转成字符串。

              静态方法：

                            staticString copyValueOf(char[]);

                            staticString copyValueOf(char[] data, int offset, int count)

                            staticString valueOf(char[])

       3.2将字符串转成字符数组。

              char[]toCharArray()

       3.3将字节数组转成字符串。

              String(byte[])

              String(byte[],offset,count):将字节数组中的一部分转成字符串。 

       3.4将字符串转成字节数组。

              byte[]  getBytes():

       3.5将基本数据类型转成字符串。

              staticString valueOf(int)

              staticString valueOf(double)

       String.valueOf(3);

             特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

4，替换

       Stringreplace(oldchar,newchar);

5，切割

       String[]split(regex);

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

       Stringsubstring(begin);

       Stringsubstring(begin,end);

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

       7.1将字符串转成大写或则小写。

               String toUpperCase();

               String toLowerCase();

       7.2将字符串两端的多个空格去除。

              Stringtrim();

       7.3对两个字符串进行自然顺序的比较。

              intcompareTo(string);

 StringBuffer

是字符串缓冲区。是一个容器。

特点：

1，长度是可变化的。

2，可以字节操作多个数据类型。

3，最终会通过toString方法变成字符串。

操作：

1，存储。

       StringBufferappend():将指定数据作为参数添加到已有数据结尾处。

       StringBufferinsert(index,数据):可以将数据插入到指定index位置。

2，删除。

       StringBufferdelete(start,end):删除缓冲区中的数据，包含start，不包含end。

       StringBufferdeleteCharAt(index):删除指定位置的字符。

3，获取。

       charcharAt(int index)

       intindexOf(String str)

       intlastIndexOf(String str)

       intlength()

       Stringsubstring(int start, int end) 

4，修改。

       StringBufferreplace(start,end,string);

       voidsetCharAt(int index, char ch) ; 

5，反转。

       StringBufferreverse(); 

6，

       将缓冲区中指定数据存储到指定字符数组中。

       voidgetChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)       

JDK1.5 版本之后出现了StringBuilder.

StringBuffer是线程同步。

StringBuilder是线程不同步。

以后开发，建议使用StringBuilder

 升级三个因素：

1，提高效率。

2，简化书写。

3，提高安全性。

 

集合：

根据数据结构分为：

Collection

        |--List:元素是有序的，元素可以重复。因为该集合体系有索引。

               |--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。

               |--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。

               |--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。 

        |--Set：元素是无序，元素不可以重复。、

Collection定义了集合框架的共性功能。

1，添加

        add(e);

        addAll(collection); 

2，删除

        remove(e);

        removeAll(collection);

        clear(); 

3，判断。

        contains(e);

        isEmpty(); 

4，获取

        iterator();

        size(); 

5，获取交集。

        retainAll();

6，集合变数组。

        toArray(); 

add方法的参数类型是Object。以便于接收任意类型对象。 

集合中存储的都是对象的引用(地址)

什么是迭代器呢？

其实就是集合的取出元素的方式。

如同抓娃娃游戏机中的夹子。

迭代器是取出方式，会直接访问集合中的元素。

所以将迭代器通过内部类的形式来进行描述。都有一个共性的判断和取出动作。

通过容器的iterator()方法获取该内部类的对象。

List：

        特有方法。凡是可以操作角标的方法都是该体系特有的方法。 

增

        add(index,element);

        addAll(index,Collection); 

删

        remove(index); 

改

        set(index,element);

查

        get(index):

        subList(from,to);

        listIterator();

        int indexOf(obj):获取指定元素的位置。

        ListIterator listIterator(); 

List集合特有的迭代器。ListIterator是Iterator的子接口。 

在迭代时，不可以通过集合对象的方法操作集合中的元素。

因为会发生ConcurrentModificationException异常。

所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，

只能对元素进行判断，取出，删除的操作，

如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

该接口只能通过List集合的listIterator方法获取。

LinkedList:特有方法：

addFirst();

addLast(); 

getFirst();

getLast();

获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

removeFirst();

removeLast();

获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException 

在JDK1.6出现了替代方法。

offerFirst();

offerLast(); 

peekFirst();

peekLast();

获取元素，但不删除元素。如果集合中没有元素，会返回null。 

pollFirst();

pollLast();

获取元素，但是元素被删除。如果集合中没有元素，会返回null。

Set: 

|--Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。、

        |--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。

                       HashSet是如何保证元素唯一性的呢？

                       是通过元素的两个方法，hashCode和equals来完成。

                       如果元素的HashCode值相同，才会判断equals是否为true。

                       如果元素的hashcode值不同，不会调用equals。

                       注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。 

        |--TreeSet：

Set集合的功能和Collection是一致的。

List总结：

1. 所有的List中只能容纳单个不同类型的对象组成的表，而不是Key－Value键值对。例如：[ tom,1,c ]；

2. 所有的List中可以有相同的元素，例如Vector中可以有 [tom,koo,too,koo ]；

3. 所有的List中可以有null元素，例如[ tom,null,1]；

4. 基于Array的List（Vector，ArrayList）适合查询，而LinkedList（链表）适合添加，删除操作。

HashSet：虽然Set同List都实现了Collection接口，但是他们的实现方式却大不一样。List基本上都是以Array为基础。但是Set则是在HashMap的基础上来实现的，这个就是Set和List的根本区别。HashSet的存储方式是把HashMap中的Key作为Set的对应存储项。看看HashSet的add（Object  obj）方法的实现就可以一目了然了。
    public boolean add(Object obj)
    {
        return map.put(obj, PRESENT) ==null;
    }

这个也是为什么在Set中不能像在List中一样有重复的项的根本原因，因为HashMap的key是不能有重复的。

LinkedHashSet：HashSet的一个子类，一个链表。

TreeSet：SortedSet的子类，它不同于HashSet的根本就是TreeSet是有序的。它是通过SortedMap来实现的。

Set总结：

1. Set实现的基础是Map（HashMap）；

2.  Set中的元素是不能重复的，如果使用add(Objectobj)方法添加已经存在的对象，则会覆盖前面的对象

为什么要使用集合类 ?

当你事先不知道要存放数据的个数，或者你需要一种比数组下标存取机制更灵活的方法时，你就需要用到集合类。

 
理解集合类

集合类存放于java.util包中。
集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference)。
集合类型主要有3种：set(集）、list(列表）和map(映射)。

(1)集
集（set）是最简单的一种集合，它的对象不按特定方式排序，只是简单的把对象加入集合中，就像往口袋里放东西。
对集中成员的访问和操作是通过集中对象的引用进行的，所以集中不能有重复对象。
集也有多种变体，可以实现排序等功能，如TreeSet，它把对象添加到集中的操作将变为按照某种比较规则将其插入到有序的对象序列中。它实现的是SortedSet接口，也就是加入了对象比较的方法。通过对集中的对象迭代，我们可以得到一个升序的对象集合。

(2)列表
列表的主要特征是其对象以线性方式存储，没有特定顺序，只有一个开头和一个结尾，当然，它与根本没有顺序的集是不同的。
列表在数据结构中分别表现为：数组和向量、链表、堆栈、队列。
关于实现列表的集合类，是我们日常工作中经常用到的，将在后边的笔记详细介绍。

(3)映射
映射与集或列表有明显区别，映射中每个项都是成对的。映射中存储的每个对象都有一个相关的关键字（Key）对象，关键字决定了对象在映射中的存储位置，检索对象时必须提供相应的关键字，就像在字典中查单词一样。关键字应该是唯一的。
关键字本身并不能决定对象的存储位置，它需要对过一种散列(hashing)技术来处理，产生一个被称作散列码(hash code)的整数值，

散列码通常用作一个偏置量，该偏置量是相对于分配给映射的内存区域起始位置的，由此确定关键字/对象对的存储位置。理想情况下，散列处理应该产生给定范围内均匀分布的值，而且每个关键字应得到不同的散列码。

集合类简介 
java.util中共有13个类可用于管理集合对象，它们支持集、列表或映射等集合，以下是这些类的简单介绍

集：
HashSet： 使用HashMap的一个集的实现。虽然集定义成无序，但必须存在某种方法能相当高效地找到一个对象。使用一个HashMap对象实现集的存储和检索操作是在固定时间内实现的.

TreeSet： 在集中以升序对对象排序的集的实现。这意味着从一个TreeSet对象获得第一个迭代器将按升序提供对象。TreeSet类使用了一个TreeMap.

列表：
Vector： 实现一个类似数组一样的表，自动增加容量来容纳你所需的元素。使用下标存储和检索对象就象在一个标准的数组中一样。你也可以用一个迭代器从一个Vector中检索对象。Vector是唯一的同步容器类!!当两个或多个线程同时访问时也是性能良好的。

Stsck: 这个类从Vector派生而来，并且增加了方法实现栈!一种后进先出的存储结构。

LinkedList: 实现一个链表。由这个类定义的链表也可以像栈或队列一样被使用。

ArrayList: 实现一个数组，它的规模可变并且能像链表一样被访问。它提供的功能类似Vector类但不同步。

映射：
HashTable： 实现一个映象，所有的键必须非空。为了能高效的工作，定义键的类必须实现hashcode()方法和equal()方法。这个类是前面java实现的一个继承，并且通常能在实现映象的其他类中更好的使用。

HashMap： 实现一个映象，允许存储空对象，而且允许键是空（由于键必须是唯一的，当然只能有一个）。

WeakHashMap： 实现这样一个映象：通常如果一个键对一个对象而言不再被引用，键/对象对将被舍弃。这与HashMap形成对照，映象中的键维持键/对象对的生命周期，尽管使用映象的程序不再有对键的引用，并且因此不能检索对象。

TreeMap： 实现这样一个映象，对象是按键升序排列的。

Set和List都是由公共接口Collection扩展而来，所以它们都可以使用一个类型为Collection的变量来引用。这就意味着任何列表或集构成的集合都可以用这种方式引用，只有映射类除外（但也不是完全排除在外，因为可以从映射获得一个列表。）所以说，把一个列表或集传递给方法的标准途径是使用Collection类型的参数。

Vector 还是ArrayList，哪一个更好，为什么？ 
要回答这个问题不能一概而论，有时候使用Vector比较好；有时是ArrayList，有时候这两个都不是最好的选择。你别指望能够获得一个简单肯定答案，因为这要看你用它们干什么。下面有4个要考虑的因素：

(1)API

(2)同步处理

(3)数据增长性

(4)使用模式

下面针对这4个方面进行一一探讨

API 
在由Ken Arnold等编著的《JavaProgramming Language》(Addison-Wesley, June2000)一书中有这样的描述，Vector类似于ArrayList.。所有从API的角度来看这两个类非常相似。但他们之间也还是有一些主要的区别的。

同步性

Vector是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的，因此ArrayList中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销。

数据增长

从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。

使用模式

在ArrayList和Vector中，从一个指定的位置（通过索引）查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？
这意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好选择其他的集合操作类。
比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的—O(1)，但它在索引一个元素的使用却比较慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也会为每个插入的元素创建对象，所以你要明白它也会带来额外的开销。

 

泛型： 

泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。 

好处：

1，将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。 

2，避免了强制转换麻烦。 

泛型格式：通过<>来定义要操作的引用数据类型。 

在使用java提供的对象时，什么时候写泛型呢？ 

通常在集合框架中很常见，

只要见到<>就要定义泛型。

其实<> 就是用来接收类型的。 

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

泛型类定义的泛型，在整个类中有效。如果被方法使用，

那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

为了让不同方法可以操作不同类型，而且类型还不确定。

那么可以将泛型定义在方法上。

特殊之处：

静态方法不可以访问类上定义的泛型。

如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

泛型定义在接口上：

interface Inter

{

        void show(T t);

}

class InterImpl implements Inter

{

        public void show(T t)

        {

               System.out.println("show :"+t);

        }

}

class GenericDemo5 

{

        public static void main(String[] args) 

        {

               InterImpl i = new InterImpl();

               i.show(4);

               //InterImpl i = new InterImpl();

               //i.show("haha");

        }

}

? 通配符。也可以理解为占位符。

泛型的限定；

？ extends E: 可以接收E类型或者E的子类型。上限。

？ super E: 可以接收E类型或者E的父类型。下限

当元素自身不具备比较性，或者具备的比较性不是所需要的。

这时需要让容器自身具备比较性。

定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

当两种排序都存在时，以比较器为主。

定义一个类，实现Comparator接口，覆盖compare方法。

Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。

        1，添加。

               put(K key, V value) 

               putAll(Map m) 

        2，删除。

               clear() 

               remove(Object key) 

        3，判断。

               containsValue(Object value) 

               containsKey(Object key) 

               isEmpty()   

        4，获取。

               get(Object key) 

               size() 

               values() 

               entrySet() 

               keySet() 

Map

        |--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。

        |--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。

        |--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。

和Set很像。

其实大家，Set底层就是使用了Map集合。

map集合的两种取出方式：

1，Set keySet：将map中所有的键存入到Set集合。因为set具备迭代器。

        所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。                

        Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。  

2，Set> entrySet：将map集合中的映射关系存入到了set集合中，

                               而这个关系的数据类型就是：Map.Entry 

                               Entry其实就是Map中的一个static内部接口。

                               为什么要定义在内部呢？

                               因为只有有了Map集合，有了键值对，才会有键值的映射关系。

                               关系属于Map集合中的一个内部事物。

                               而且该事物在直接访问Map集合中的元素。

Map.Entry 其实Entry也是一个接口，它是Map接口中的一个内部接口。

Arrays用于操作数组的工具类：

里面都是静态方法。

asList:将数组变成list集合

把数组变成list集合有什么好处？

可以使用集合的思想和方法来操作数组中的元素。

注意：将数组变成集合，不可以使用集合的增删方法。

因为数组的长度是固定。

contains。

get

indexOf()

subList();

如果你增删。那么会反生UnsupportedOperationException,

如果数组中的元素都是对象。那么变成集合时，数组中的元素就直接转成集合中的元素。

如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

集合框架的工具类：

Collections:集合框架的工具类。里面定义的都是静态方法。 

Collections和Collection有什么区别？

Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。

               它有两个常用的子接口，

               List：对元素都有定义索引。有序的。可以重复元素。

               Set：不可以重复元素。无序。 

Collections是集合框架中的一个工具类。该类中的方法都是静态的

               提供的方法中有可以对list集合进行排序，二分查找等方法。

               通常常用的集合都是线程不安全的。因为要提高效率。

               如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

Collections的fill方法可以将list集合中所有元素替换成指定元素。将list集合中部分元素替换成指定元素。

Collections.fill(list,str); 

1,指定类型的数组到底要定义多长呢？

               当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。

               当指定类型的数组长度大于了集合的size，就不会新创建了数组。而是使用传递进来的数组。

               所以创建一个刚刚好的数组最优。

2,为什么要将集合变数组？

               为了限定对元素的操作。不需要进行增删了。

另一咱高效集合变数组的方法：

这样的话就可以先创建一个List集合再把集合变数组

ArrayList al = new ArrayList();

String[] arr = al.toArray(new String[al.size()]);

System.out.println(Arrays.toString(arr));

关于集合的遍历：

高级for循环

格式：

for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)

{        

} 

对集合进行遍历。

只能获取集合元素。但是不能对集合进行操作。

迭代器除了遍历，还可以进行remove集合中元素的动作。

如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别呢？

高级for有一个局限性。必须有被遍历的目标。

建议在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。

可变参数定义：

可变参数：

       其实就是上一种数组参数的简写形式。

       不用每一次都手动的建立数组对象。

       只要将要操作的元素作为参数传递即可。

       隐式将这些参数封装成了数组。

方法的可变参数：

在使用时注意：可变参数一定要定义在参数列表最后面。

Public static void method(String str,int...arr){}

把一个可变int数组当作参数传到方法method