黑马程序员---------String类、集合--

------------Android培训、java培训、期待与您交流------------

第1讲  String类

一、 String类出现的意义

    字符串是一个特殊的对象。

    字符串一旦初始化就不可以被改变。

字符串操作是程序中最基本和常见的的方法，如果不将其封装成类就会给我们的开发带来不便

    java为我们提供的String类，为我们提供了字符串操作的解决方案。

    String类适用于描述字符串事物，那么它就提供了多个方法对字符串进行操作。

二、字符串常见操作

    字符串最基本操作：增、删、改、查。

1、获取

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

int length():获取长度。

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

char charAt(int index):

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

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

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

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

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

int lastIndexOf(int ch) ：返回的是ch在字符串中最后一次出现的位置。

2，判断

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

boolean contains(str):

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

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

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

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

2.2 字符中是否有内容。

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

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

boolean startsWith(str);

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

boolean endsWith(str);

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

boolean equals(str);

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

boolean equalsIgnoreCase();

3，转换

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

构造函数：String(char[])  //  String str = new String(char[]);

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

静态方法：

static String copyValueOf(char[]);

static String copyValueOf(char[] data, int offset, int count) 

static String valueOf(char[]):

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

char[] toCharArray():

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

String(byte[])

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

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

byte[]  getBytes():

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

static String valueOf(int)

static String valueOf(double)

3+"";//String.valueOf(3);

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

4、替换

String replace(oldchar,newchar);

5、切割

String[] split(regex);

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

String substring(begin);

String substring(begin,end);

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

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

String toUpperCase();

String toLowerCase();

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

String trim();

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

int compareTo(string);

以下代码包含了上面的方法：

<span style="font-size:14px;">class  StringMethodDemo
{
	public static void method_7()
	{
		String s = "    Hello Java     ";
		sop(s.toLowerCase());
		sop(s.toUpperCase());
		sop(s.trim());
		String s1 = "a1c";
		String s2 = "aaa";

		sop(s1.compareTo(s2));
	}
	public static void method_sub()
	{
		String s = "abcdef";

		sop(s.substring(2));//从指定位置开始到结尾。如果角标不存在，会出现字符串角标越界异常。
		sop(s.substring(2,4));//包含头，不包含尾。s.substring(0,s.length());
	}
	public static void  method_split()
	{
		String s = "zhagnsa,lisi,wangwu";
		String[] arr  = s.split(",");
		for(int x = 0; x<arr.length; x++)
		{
			sop(arr[x]);
		}
	}
	public static void method_replace()
	{
		String s = "hello java";
		//String s1 = s.replace('q','n');//如果要替换的字符不存在，返回的还是原串。
		String s1 = s.replace("java","world");
		sop("s="+s);
		sop("s1="+s1);
	}
	public static void method_trans()
	{
		char[] arr = {'a','b','c','d','e','f'};
		String s= new String(arr,1,3);
		sop("s="+s);
		String s1 = "zxcvbnm";
		char[] chs = s1.toCharArray();
		for(int x=0; x<chs.length; x++)
		{
			sop("ch="+chs[x]);
		}
	}
	public static void method_is()
	{
		String str = "ArrayDemo.java";		
		//判断文件名称是否是Array单词开头。
		sop(str.startsWith("Array"));
		//判断文件名称是否是.java的文件。
		sop(str.endsWith(".java"));
		//判断文件中是否包含Demo
		sop(str.contains(".java"));
	}
	public static void method_get()
	{
		String str = "abcdeakpf";
		//长度
		sop(str.length());
		//根据索引获取字符。
		sop(str.charAt(4));//当访问到字符串中不存在的角标时会发生StringIndexOutOfBoundsException。
		//根据字符获取索引
		sop(str.indexOf('m',3));//如果没有找到，返回-1.		
		//反向索引一个字符出现位置。
		sop(str.lastIndexOf("a"));		
	}
	public static void main(String[] args) 
	{
		method_7();
		method_trans();
		method_is();
		method_get();
		String s1 = "abc";
		String s2 = new String("abc")；
		String s3 = "abc";
		System.out.println(s1==s2);
		System.out.println(s1==s3);
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}</span>

字符串操作练习：

    获取一个字符串在另一个字符串中出现的次数。

思路：

    1、定义个计数器。

    2、获取kk第一次出现的位置。

    3、从第一次出现位置后剩余的字符串中继续获取kk出现的位置，每获取一次就计数一次。

    4、当获取不到时，计数完成。

<span style="font-size:14px;">class  StringTest
{
	public static int getSubCount(String str,String key)
	{
		int count = 0;
		int index = 0;

		while((index=str.indexOf(key))!=-1)
		{
			sop("str="+str);
			str = str.substring(index+key.length());

			count++;	
		}
		return count;
	}

	 //方式二。
	public static int getSubCount_2(String str,String key)
	{
		int count = 0;
		int index = 0;

		while((index= str.indexOf(key,index))!=-1)
		{
			sop("index="+index);
			index = index + key.length();

			count++;
		}
		return count;
	}

	public static void main(String[] args) 
	{
		String str = "kkabkkcdkkefkks";
		sop("count="+getSubCount_2(str,"kk"));
	}

	public static void sop(String str)
	{
		System.out.println(str);
	}
}</span>

三、StringBuffer是字符串缓冲区。

是一个容器。

特点：

1、长度是可变化的。

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

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

1、存储

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

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

2、删除

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

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

3、获取

char charAt(int index) : 获取指定位置的字符

int indexOf(String str) :获取字符串出现的位置

int lastIndexOf(String str) :获取最后出现字符串的位置

int length() : 获取长度

String substring(int start, int end) : 获取缓冲区中的数据，包含start，不包含end。
 
4、修改

StringBuffer replace(start,end,string); 替换缓冲区数据，包含start，不包含end。

void setCharAt(int index, char ch) ; 将指定位置换成新字符

5、反转

StringBuffer reverse();

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

void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 

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

    StringBuffer是线程同步。

    StringBuilder是线程不同步。

以后开发，建议使用StringBuilder

升级三个因素：

1、提高效率。

2、简化书写。

3、提高安全性。

四、基本数据类型对象包装类

byte          Byte
short       short
int          Integer
long         Long
boolean   Boolean
float          Float
double     Double
char         Character

基本数据类型对象包装类的最常见作用，

    就是用于基本数据类型和字符串类型之间做转换

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

    基本数据类型+""

    基本数据类型.toString(基本数据类型值);

如： Integer.toString(34);//将34整数变成"34";

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

    xxx a = Xxx.parseXxx(String);

    int a = Integer.parseInt("123");

    double b = Double.parseDouble("12.23");

    boolean b = Boolean.parseBoolean("true");

    Integer i = new Integer("123");

    int num = i.intValue();

十进制转成其他进制。

    toBinaryString();

    toHexString();

    toOctalString();

其他进制转成十进制。

    parseInt(string,radix);

JDK1.5版本以后出现的新特性。

    自动装箱、自动拆箱

见下例：

<span style="font-size:14px;">class IntegerDemo1 
{
	public static void main(String[] args) 
	{
		Integer x = 4;//自动装箱。//new Integer(4)   x是对象

		x = x/* x.intValue() */ + 2;//x+2:x 进行自动拆箱。变成成了int类型。和2进行加法运算。
					//再将和进行装箱赋给x。
		Integer m = 128;
		Integer n = 128;
		sop("m==n:"+(m==n)); //false
		Integer a = 127;
		Integer b = 127;
		sop("a==b:"+(a==b));//结果为true。因为a和b指向了同一个Integer对象。	//因为当数值在byte范围内容，对于新特性，如果该数值已经存在，则不会在开辟新的空间。
		method();
	}

	public static void method()
	{
		Integer x = new Integer("123");
		Integer y = new Integer(123);
		sop("x==y:"+(x==y));
		sop("x.equals(y):"+x.equals(y));
	}
	public static void sop(String str)
	{
		System.out.println(str);
	}	
}</span>

执行结果

第2讲  集合

一、集合类

为什么出现集合类？

    面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一 种方式。

为什么出现这么多的容器呢？

    因为每一个容器对数据的存储方式都有不同。这个存储方式称之为：数据结构。

数组和集合类同是容器，有何不同？

    数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

集合类的特点

    集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

二、集合框架的构成及分类

Collection

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

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

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

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

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

              |--HashSet：数据结构是哈希表。线程是非同步的。

                                     保证元素唯一性的原理：判断元素的hashCode值是否相同。

                                     如果相同，还会继续判断元素的equals方法，是否为true。

              |--TreeSet：可以对Set集合中的元素进行排序。

                                    底层数据结构是二叉树。

                                   保证元素唯一性的依据：

                                   compareTo方法return 0.

                  TreeSet排序的第一种方式：让元素自身具备比较性。

                  元素需要实现Comparable接口，覆盖compareTo方法。

                  也种方式也成为元素的自然顺序，或者叫做默认顺序。

                  TreeSet的第二种排序方式。

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

                  这时就需要让集合自身具备比较性。

                 在集合初始化时，就有了比较方式。

三、list集合

1.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方法获取。

2.ArrryList基本操作演示：

<span style="font-size:14px;">import java.util.*;
class ListDemo 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void method()
	{		
		ArrayList al = new ArrayList();
		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		
		sop("原集合是："+al);
		//在指定位置添加元素。
		al.add(1,"java09");

		//删除指定位置的元素。
		//al.remove(2);

		//修改元素。
		//al.set(2,"java007");

		//通过角标获取元素。
		sop("get(1):"+al.get(1));

		sop(al);

		//获取所有元素。
		for(int x=0; x<al.size(); x++)
		{
			System.out.println("al("+x+")="+al.get(x));
		}
		Iterator it = al.iterator();

		while(it.hasNext())
		{
			sop("next:"+it.next());
		}
		//通过indexOf获取对象的位置。
		sop("index="+al.indexOf("java02"));
		List sub = al.subList(1,3);
		sop("sub="+sub);
	}	
	public static void main(String[] args) 
	{

		//演示列表迭代器。
		ArrayList al = new ArrayList();
		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		sop(al);		
		ListIterator li = al.listIterator();	
		//sop("hasPrevious():"+li.hasPrevious());
		while(li.hasNext())
		{
			Object obj = li.next();

			if(obj.equals("java02"))
				//li.add("java009");
				li.set("java006");
		}

		while(li.hasPrevious())
		{
			sop("pre::"+li.previous());
		}
		//sop("hasNext():"+li.hasNext());
		//sop("hasPrevious():"+li.hasPrevious());
		sop(al);

	}
}</span>

3.Vector
枚举是Vector特有的取出方式。

发现枚举和迭代器很像。

其实枚举和迭代是一样的。

    因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

4.LinkedList

LinkedList:特有方法：

    addFirst();

    addLast();

    getFirst();

    getLast();

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

    removeFirst();

    removeLast();

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

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

    offerFirst();

    offerLast();

    peekFirst();

    peekLast();

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

    pollFirst();

    pollLast();

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

四、set集合

HashSet：线程不安全，存取速度快。

    保证唯一性的原因：

    判断元素的hashCode值是否相同，如果相同，还会继续判断元素的equals方法，是否为true。

TreeSet：线程不安全，可以对Set集合中的元素进行排序。

    底层数据结构是二叉树。

     保证元素唯一性的依据：compareTo方法return 0.

     TreeSet排序的第一种方式：让元素自身具备比较性。          

    第二站排序方式：当元素不具备比较性或者不是需要的比较性时，让集合自身具备比较性               

练习：往hashSet集合中存入自定对象

    姓名和年龄相同为同一个人，重复元素。

<span style="font-size:14px;">class HashSetTest 
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet hs = new HashSet();

		hs.add(new Person("a1",11));
		hs.add(new Person("a2",12));
		hs.add(new Person("a3",13));
		hs.add(new Person("a2",12));
		//sop("a1:"+hs.contains(new Person("a2",12)));			
		//hs.remove(new Person("a4",13));
		Iterator it = hs.iterator();
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}
	}
}
class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}	
	public int hashCode()
	{
		System.out.println(this.name+"....hashCode");
		return name.hashCode()+age*37;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;

		Person p = (Person)obj;
		System.out.println(this.name+"...equals.."+p.name);

		return this.name.equals(p.name) && this.age == p.age;
	}	
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}</span>

    HashSet集合存入数据时会先比较hashcode值，如果值一样再比较equals方法。

为了能够完成我们想要的功能，一般会复写hashcode和equals方法，

集合会自动调用复写的hashcode和equals方法。