黑马程序员--Java--集合

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

Sting、StringBuffer和StringBuilder

1.1 String类的特点：

1.一旦被创建就不可以被改变
  例：String s = "abc";
      s = "zxc";

  "abc"对象并未发生改变，只是引用变量s指向了新的字符串。

2.String s1 = "abc";
  String s2 = "abc";
  String s3 = new String("abc");
  s1 == s2;
  s1 != s3;
  s1.equals（s3）;//true
  分析：s2创建的时候，"abc"已经存在于字符串常量池中，故引用变量s2直接指向了已经存在的"abc"字符串对象。"=="比较的是地址值。
        s3是在堆内存中创建的另外一个对象。所以s1、s3不是同一个对象。

        String类复写了Object的equals方法，比较的是字符串类容，而不是地址值。

3.方法：
 1）获取
 int length():字符串长度
 char charAt(int index):某位置上的字符
 int indexOf(int ch):某字符(可输入字符或对应的ASK码值)的位置，若没有返回-1.
 int indexOf(String str):某字符串位置
 int indexOf(String str,int fromIndex):从某一位开始找字符串位置。
 int lastIndexOf(...):反向索引。

 2）判断
 boolean contains(String str)：是否含有某字符串。
 boolean isEmpty()：长度是否是0。
 boolean startsWith(String str)：是否以某字符串开头。
 boolean endsWith(String str)：是否以某字符串结尾。
 boolean equals(String str)：比较两字符串是否相同。
 boolean equalsIgnoreCase(String str)：不管大小写两字符串是否相同。

 3）转换
 将char[]转换成string：
  构造方法，String(char[]),String(char[],start,length)
 将String转换成char[]：
  String toCharArray()
 将byte[]转换成String：
  构造方法，String(byte[]),String(byte[],start,length)
 将String转换成byte[]：
  byte[] getBytes()
 
 4）替换
 String replace（old，new）
 String replaceAll（old，regex）//用到正则表达式。

 5）切割
 String[] split（str）//指定字符串或者正则表达式。

 6）子串
 String substring（begin ，end）//包含头不包含尾
 
 7）切换大小写
 String toUpperCase（）;
 String toLowerCase（）;

 8）比较

 int conpareTo（String str）：0代表两字符串相等，小于0代表按字母顺序在参数前，反之在其后。

4.练习
  需求：一个子串在字符串中出现的次数
代码：

public class StringTest{
	public static void main(String[] args){
		String str = "jnbaffnbagisnbasoofnbafhyenba";
		String key = "nba";
		
		int count = getKeyCount(str,key);
		System.out.println("count = "+count);
	}


	public static int getKeyCount(String str , String key){
		int count = 0;
		int index = str.indexOf(key);
		while(index!=-1){
			index = str.indexOf(key,index+key.length());
			//str = str.substring(index+key.length());
			count++;
		}
		return count;
	}
}

运行结果：count = 5

 需求：两个字符串中最大相同子串
代码：

public class StringTest{
	public static void main(String[] args){
		String s1 = "qwerabcdtyuiop";
		String s2 = "xcabcdngf";
		
		String s = getMaxSubstring(s1,s2);
		System.out.println("s = "+s);
	}


	public static String getMaxSubstring(String s1,String s2){
		if(s1.length()<s2.length()){
			String temp = s1;
			s1 = s2;
			s2 = temp;			
		}
		for(int x = s2.length();x>0;x--){
			for(int y=0,z=x;z<s2.length();y++,z++){
				String sub = s2.substring(y,z);
				if(s1.contains(sub)){
					return sub;
				}
			}
		}
		return null;
	}
}

运行结果：s = abcd

1.2 StringBuffer：就是字符串缓存区，用错存储数据的容器。

1.特点：
 长度可变，可以存储不同的数据，最终通过toString方法获得字符串。

2.方法
 1）添加
 sb.append(数据):将指定数据做为参数添加到已有数据的结尾
 sb.insert(index，数据):将数据插到指定位置
 2）删除
 sb.delet(start,end)：包含头，不包含尾。
 sb.delet(index)：删除指定位置的元素。
 3）查找
 char charAt(int index)：获取某位置上的字符。
 int indexOf(String str)
 int lastIndexOf(String str)
 4）修改
 sb.replace(start,end,new):
 void setCharAt(index,char):
 5）反转
 sb.reverse();
 6）将缓存区的字符存入字符数组中
 void getChars(start,end,char[],charBegain):

1.3 StringBuilder：jdk1.5后出现的与StringBuffer一样功能的对象。

与StringBuffer不同点：
1、StringBuffer是线程同步的，通常用于多线程。

2、StringBuilder是线程不同步的，多用于单线程，提高了程序效率。

常用基本类型

2.1 基本数据类型包装类

 为了方便基本数据类型的操作。把其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。
 8种基本数据类型包装类：
 byte      Byte
 short     Short
 int       Integer  
 long      Long
 float     Float
 double    Double
 char      Character
 boolean   Boolean
 
字符串 <---> 基本数据类型：
 基本类型--->字符串
  1、基本数据类型+""；
  2、Integer.toString(1234)；
  3、String.valueOf(基本类型)；
 字符串-->基本类型
  基本数据类型 参数 = 基本数据类型包.parse数据类型（String str）；
  如：Int i = Integer.parseInt("12345");

十进制转其他进制
 String toBinaryString(int);
 String toOctalString(int);
 String toHexString(int);
 String toString(int i,int radix);
其他进制转十进制
 int parseInt(String s,int radix);

集合类

3.1 集合类概念

由来：数据多了用对象存储，对象多了用集合存储。

特点：
1.用于存储对象的容器。
2.集合的长度是可变的。
3.集合中不可以存储基本数据类型值。

数组和集合的不同：
数组长度是固定的，集合长度可变。数组中可有储存基本数据类型，集合中只能存储对象。

集合框架：
collection（接口）
  |--list 有序（存入和取出一致），元素都有索引（角标），允许重复元素。
    |--ArrayList  内部是数组数据结构，但不是同步的，代替了vector，查询快
    |--LinkedList 内不是链表数据结构的，不是同步的，增删快
    |--Vector     内不是数组数据结构的，是同步的，增删、查询都很慢。
  |--set  元素不能重复，无序。
    |--HashSet    内部数据结构是哈希表，是不同步的。
    |--TreeSet    可以对set集合中的元素排序，是不同步的

3.2 常见方法

 1）添加
 boolean  add(Object obj)：存放的是对象的地址值。
 2）获取
 int size()：集合长度。
 3）删除
 boolean remove()：
 void clean()：
 4）判断
 boolean contains();
 boolean isEmpty();
 取出集合中的元素：迭代器
 Iterator i = a.iterator();
 while(i.hasNext()){
sop(i.next());//注意一个hasNext中只有一个next，多个容易出现错误。
 }
 for（Object obj ：a）
 5）其他
 boolean retainAll(collection c):取两个集合的交集。
 Object toArray()：集合变数组。

3.3 List集合

1.list特有方法
 add（index ，element）：在指定位置添加元素。
 addAll(index , collection)
 remove(index)
 set(index , element)
 get(index)
 indexOf(Object)
 lastIndexOf(object)
 subList(from,to)

2.vector的枚举方式
 Enumeration e = v.elements();
 while(e.hasMoreElements()){
sop(e.nextElement());
 }
 枚举和迭代一样，但名字过长后被Iterator取代。

3.LinkedList中的方法。
 添加：addFirst() , addLast()
 获取：getFirst() , getLast()
 删除：removeFirst() , removeLast()
 以上方法，如果元素不存在，则返回 NoSuchElementException。
但在JDK1.6后，有了新方法，若没有返回null。
 添加：pollFirst() , pollLast()
 获取：peekFirst() , peekLast()
 删除：offerFirst() ,offerLast() 

练习：
1.需求：用LinkedList模拟一个堆栈(元素先进后出)。
代码：

public class ZhanDemo{
	public static void main(String[] args){
		Zhan z = new Zhan();
		
		z.myAdd("abc1");
		z.myAdd("abc2");
		z.myAdd("abc3");
		z.myAdd("abc4");
		
		System.out.println(z.toString());
	}
}

class Zhan{
	private LinkedList<String> link;
	Zhan(){
		link= new LinkedList<String>();
	}
	public void myAdd(String str){
		link.addFirst(str);
	}
	public String toString(){
		return link.toString();
	}
}

运行结果：[abc4, abc3, abc2, abc1]

2.需求：去除ArrayList集合中重复的元素
代码：

import java.util.*;

class Person{
	private String name;
	private int age;
	
	Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	
	public boolean equals(Object obj){
		if(obj == this){
			return true;
		}
		if(!(obj instanceof Person)){
			throw new ClassCastException("类型错误");
		}
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age ==p.age;
	}
	public String toString(){
		return name+"..."+age;
	}
}
public class ArrayListDemo{
	public static void main(String[] args){
		ArrayList<Person> a = new ArrayList<Person>();
		
		a.add(new Person("lisi1",21));
		a.add(new Person("lisi2",22));
		a.add(new Person("lisi3",23));
		a.add(new Person("lisi4",24));
		a.add(new Person("lisi4",24));


		System.out.println(a);


		ArrayList<Person> a1 = getSingleElement(a);
		
		System.out.println(a1);
	}
	public static ArrayList<Person> getSingleElement(ArrayList<Person> a){
		ArrayList<Person> a1 = new ArrayList<Person>();
		for(Person person : a){
			Person p = person;
			if(!(a1.contains(p))){
				a1.add(p);
			}
		}
		return a1;
	}
}

运行结果：
[lisi1...21, lisi2...22, lisi3...23, lisi4...24, lisi4...24]
[lisi1...21, lisi2...22, lisi3...23, lisi4...24]

3.4 Set集合

1.HashSet判断两个元素是否形同的步骤：
 判断两个元素的哈希值（hashCode）是否相同，如果相同，再判断两个对象是否相同（equals方法），如果hashCode不同，不需要判断equals。
 往HashSet集合中存入对象时，该对象必须复写hashCode和equals方法：
public int hashCode（）{}
public boolean equals（Object obj）{}

2.TreeSet判断元素的唯一办法：就是根据比较方法的返回值是否是0，为0则相同。
 TreeSet排序方式：
 1）让元素自己具备计较功能，元素就要实现Comparable接口，覆盖其方法compareTo(Object)方法。
 2）自定义比较器。不用元素自身的比较方法，让集合自己具备计较方法，定义一个类实现Comparator，实现其方法compare(Object obj1,Object obj2)。
 
练习：对字符串进行长度排序
代码：

import java.util.*;

class TreeSetDemo 
{
	public static void main(String[] args) 
	{

		TreeSet<String> ts = new TreeSet<String>(new MyComparator());

		ts.add("dasd");
		ts.add("fa");
		ts.add("das");
		ts.add("ffdsf");
		ts.add("fdsffds");
		ts.add("dfsd");
		ts.add("dfdffasa");

		System.out.println(ts);
	}
}
class MyComparator implements Comparator<String>
{
	public int compare(String s1,String s2){
		int num =s1.length()-s2.length();
		return num==0?s1.compareTo(s2):num;
	}
}

运行结果：
[fa,das,dasd,dfsd,ffdsf,fdsffds,dfdffasa]

3.5 Map集合

Map
  |--Hashtable  底层为哈希表，不可存入null，集合是同步的。
    |--Properties  用来存储键值对型的配置文件信息，可以和IO流技术相结合。
  |--HashMap    底层为哈希表，可存入null，集合是不同步的。
  |--TreeMap    底层为二叉树，可给Map元素排序。

特点：
一次添加一对元素以键值对存在，且必须保证键的唯一性，collection一次添加一个元素。Map也称为双列集合，Collection集合为单列集合。

常用方法：
 1）添加
 put(key,value)：返回值为key以前对应的值。
 2）删除
 claer()：清空Map集合
 remove(key)：删除key对应的键值对
 3）判断
 containsKey(key)
 containValue(value)
 isEmpty()
 4）获取
 value get(key):通过键返回值，若没有返回null。
 int size()：键值对个数。

获取Map集合并打印
1.keySet
示例代码：

import java.util.*;

class  MapDemo
{
	public static void main(String[] args) 
	{
		Map<Integer,String> m = new HashMap<Integer,String>();

		m.put(1,"zhangdan");
		m.put(2,"lisi");
		m.put(3,"wangwu");
		m.put(4,"zhaoliu");
		
		Set<Integer> s = m.keySet();

		for (Integer i : s )
		{
			int key = i;
			String value = m.get(i);
			System.out.println("key = "+key+"  value = "+value);
		}
	}
}

2.entrySet
示例代码：

import java.util.*;

class  MapDemo
{
	public static void main(String[] args) 
	{
		Map<Integer,String> m = new HashMap<Integer,String>();

		m.put(1,"zhangdan");
		m.put(2,"lisi");
		m.put(3,"wangwu");
		m.put(4,"zhaoliu");
		
		Set<Map.Entry<Integer,String>> s = m.entrySet();

		Iterator<Map.Entry<Integer,String>> it = s.iterator(); 

		while (it.hasNext())
		{
			Map.Entry<Integer,String> entry= it.next();
			int key = entry.getKey();
			String value = entry.getValue();
			System.out.println("key = "+key+"  value = "+value);
		}
	}
}

练习："fdqavcbsacdfs"获取该字符串中，每个字母出现的次数。要求打印结果为：a（2）b（1）....
代码：

import java.util.*;

class MapTest 
{
	public static void main(String[] args) 
	{
		String str = "fdqavcbsacdfs";

		TreeMap<Character,Integer> hm = getCaseTime(str);

		Set<Character> s = hm.keySet();

		for(Character c : s){
			int time = hm.get(c);
			System.out.print(c+"("+time+")");
		}	
	}

	public static TreeMap<Character,Integer> getCaseTime(String str){
		TreeMap<Character,Integer> hm = new TreeMap<Character,Integer>();
		char[] arr = str.toCharArray();

		for(char c : arr){
			if(!hm.containsKey(c)){
				hm.put(c,1);
			}
			else{
				int value = hm.get(c);
				value++;
				hm.put(c,value);
			}
		}
		return hm;
	}
}

运行结果：
a(2)b(1)c(2)d(2)f(2)q(1)s(2)v(1)

应用：在查表法中的应用较为多见。

3.6 Collections工具类

特点：是集合框架的工具类，里面方法都是静态的。

方法：
1.Collections.sort(List,new Comparator)：用默认/指定排序方法对List集合排序。

2.Collections.max(List,new Comparator)：用自然顺序/自顶排序方法选出List集合中最大的元素。

3.Collection.binarySearch(List,element)：折半查找List中指定元素。

4.Collections.fill(list,"t")：把list中所有元素都换成t。

5.Collections.replaceAll(list,"aa","bb")：把list中aa全部换成bb。

6.Collections.reverse(list)：将list中元素反转排序。

7.Collections.reverseOrder(new MyComparator)：返回一个与MyComparator相反排序方式的比较器。

8.Collections.synchronizedList(list):
  Collections.synchronizedSet(Set):      返回一个同步的集合。
  Collections.synchronizedMap(Map):

9.Collections.shuffle(list)：将集合中元素随机排序。

3.7 数组 <----> 集合

Arrays数组类中：Array.asList(arr):将数组转换成集合，可用contains、indexOf、subList等方法，但不能对此集合进行增删。

Collection中的toArray()。