黑马程序员——java基础之string及集合

                    ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

   前记：这篇写的比预期时间晚了1天多，因为中间有事耽误了一天。另外参阅了其他同学的博客，发现自己写的时候没有注重格式，因而导致不是很美观，而且调理性不够，接下来的几篇后有所注意。

   对于java的学习，有String和集合两处的学习，由于有部分学习的不佳，但是又不难慢了进度，因此把一部分的代码练习放在了博客的最后，便于代码的联系，和代码的记忆。这部门主要还是以理论为主。

String：

一、string字符串   

     String的概念： java  lang包中的String类，操作字符串的。

                     String s =new String（）；和String s1=“”；一回事。

      示例 ：String s1 =“abc”：“abc”是一个对象，s1是一个类类型的变量。 

      特点：字符串最大的特点是“abc”一被初始化，值就不会在变。

      其他：object类中的equals方法比较的是内存地址。

                 s1.equals（s2）；用于判断字符串是否相同。

      String s1 = “abc”；String s2 = new String（“abc”）；

      区别----s1在内存中有一个对象，s2有两个。

     String类的方法：String描述字符串类的，提供了多个方法对字符串进行操作，

                                        常见的方法为：1，获取。2，判断。

      1、获取：1-获取长度：int  length（）；

                     2-根据位置获取字符：char charAt（int index）；

                      3--根据字符获取位置：

                     int     indexOf（int ch ）第一次出现的位置   

                     int indexOf （int ch，int fromIndex）从指定位置开始；

                      4--反向索引Last

      2、判断：1-字符串是否包含某个字符？boolean containt（str）     

                      字符串是否为空？isEmpty。原理为是否为0   

                      字符串是否以指定内容开头？ boolean startWith（str）

                      字符串是否以指定内容结尾？end  字符串的内容是否相同 。

                       equals（str）；  忽略大小写比较字符串内容是 否相同

                      boolean  equalsIgnoreCase（）；

      3、转换：1-字符数组转换成字符串 

                     构造函数方式String（char[]） 静态方法static String copyValueOf(char[])

                     2-字符串转换成字符数组  char[] toCharArray（）：

                     3-字节数组转换成字符串 

                      构造函数方式String（byte[]） 静态方法static String copyValueOf(byte[])

                     4-字符串转换成字节组     byte[] getBytes（）：

                     5-将基本数据类型转换成字符串   String valueOf（）

       4、替换：String replace（oldchar，newchar）如果要替换的字符不存在，返回的还是原串。

       5、切割：String []split（reges）；

       6、字串：获取字符串中的一部分     String substring（begin，end）

       7、转换大小写：String toUpperCase（）；toLowerCase（）；

       8、去除两端的空格：String trim();    

       9、比较：int compareTo（String）；

String容器

一、StringBuffer

         概念：StringBuffer是一个字符串缓冲区。是一个容器。

         功能：存储StringBuffer append（），insert（index，数据）。

         删除：delete（start，end）；包含start 不包含 end。deleteCharAt（index）

                 {清空缓冲区---delete（0，sb.length()-1）;}

         获取：char charAt(int index)    int indexOf（）   int length（）

         修改：StringBuffer replace（int start，int end，String str）    void setCharAt（int index，char ch）；

         反转：StringBuffer  reverse（）

         其它：StringBuffer可以通过toString变成字符串。

 二、StringBuilder

         StringBuilder：不保证同步。一般都用StringBuilder。多线程，不安全。

         基本数据类型包装类：作用，用于基本数据类型和字符串类型做转换。

         基本数据类型转换成字符串类型：基本数据类型+“”或者Integer.toString(34);

         字符串转基本数据类型：xxx a = xxx.parsexxx.(String) int a=Integer.parseInt(“123”)

         其他类型转换成十进制：parseInt（string，radix）

         parseInt是静态的。 Integer i=new （“123”） int num =i.intValue();

         新特性：Integer x = new Integer（4）----〉Integer x =  4

         注意：使用一般都要判断是否为空。

集合框架：

   概念：集合是存对象的。方便对对象进行操作。

   数组与集合区别：数组是固定长度的，集合是可变的。集合只能存储对象。

   注意：集合框架是不断向上抽取出来的，是工具包中的成员。

   Collection有两个子接口---List  Set

   1、 List---ArrayList，LinkedList，Vector

   2、Set---HashSet,TreeSet(具体容器的名称)

   每一个容器对数据的存储方式都不同，这个方式叫数据结构。

   Collection方法：add(object) 添加任意元素，addAll能添加一组元素，

                   clear（）清空元素，remove（）移除元素，

                   removeAll（）移除一堆元素,contains（）是否存在。

                   是否为空，isEmpty（）。returnAll（）取交集。

   iterator（）迭代

   示例：创建一个集合容器： ArrayList al =new ArrayList（）；

         创建一个对象，这个对象能装对象。

         添加元素：al.add("java1");获取个数，集合长度：al.size();

   ##注意：集合中存的都是地址值，或者对象的引用。不是对象实体。

   重点：获取元素，iterator是一个接口，有next（） hasnext（）

         判断是否还有下一个元素，有的话返回真，           

         remove。示例Iterator i = al.iterater();  i.next();获取下一个元素。  

         while（it.hasnext()）        {it.next();}

   迭代器：就是用于取出集合中元素的方式，就和遍历一样。

           特点：对于取出需要多个功能体现，需要定义一个对象，

           这个类定义在集合内（内部类），先要先判断是否为空，在取出。

一、List集合

    List集合：元素是有序的，元素可以重复，元素有索引。

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

    List集合内特有方法：指定位置插入元素。判断元素位置。按照角标位置移除。 

                       改set（index，element）

                       查get（index），subList（from，to），listIterator。

    另外：因为List有角标，可以进行for遍历。

    迭代：先拿到迭代器--Iterator it =集合.iterator();

    列表迭代器：listIterator在迭代工程中添加或者删元素。并发修改异常。

                是Iterator的子接口

    列表迭代器的使用方式：获取到listIterator，ListIterator li =al.ListIterator();

    其它：hasPrevious  逆向判断前面是否还有元素，有返回true

    List根据底层数据结构不同分为：1、LinkedList，链表结构，增删快，查询慢。

                                  2、ArrayList，数组结构---查询速度很快，增删慢，

                                    默认长度为10，多的加50%。

                                  3、Vector，底层是数组数据结构，

                              和ArrayList一样---但是是同步的，被替代。200% 延长。

    1，LinkedList:

    特有方法：addFirst，addLast，get，remove    

              get方法获取元素，但是不删除元素。1.6之后出现peek， offer，poll。

    另外：迭代中，next出现一次就要hasNext一次。

    强转：person p = （person）it.next(）；

二、Set集合：

     功能与collection一致，因为没有角标。

     HashSet：底层数据结构是hash表。地址一样，equals名称不一样，顺延。线程非同步。

     HashSet能保证元素的唯一性；hasbcode和equals完成的。hash值不同才进行equals比较。

     自定义存储对象代码：

     

<span style="font-family:SimSun;font-size:18px;">class TreeSetDemo 
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi02",22));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("lisi09",19));
		ts.add(new Student("lisi08",19));		
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}
	}
}
class Student implements Comparable//该接口强制让学生具备比较性。
{
	private String name;
	private int age;

	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public int compareTo(Object obj)
	{
		//return 0;		
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;
		System.out.println(this.name+"....compareto....."+s.name);
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
		{
			return this.name.compareTo(s.name);
		}
		return -1;
	}

	public String getName()
	{
		return name;

	}
	public int getAge()
	{
		return age;
	}
}</span>

     HashSet判断删除依据：contains    remove    依赖hashCode和equals方法。

     一，TreeSet特点：可以对集合中的元素进行排序。排序对象要具备可比较性。

     排序时：主要条件相同时，一定要判断次要条件。

     ##二叉树数据结构，可以提高比较效率。二叉树中取元素，先找小的。

                     保证元素唯一性的依据是compareTo return 0.

     二、TreeSet排序：1，让元素自身具备比较性，实现compare接口，覆盖compareTo方法。

                       ---元素自然顺序

                      2，当元素自身不具备比较性，要让集合自身具备比较性。

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

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

     注意：排序两个要素-----集合，元素

三、泛型：

     泛型：是一个安全机制，避免强转。集合框架中很常见。

     格式：通过〈〉定义要操作的引用数据类型。Demo〈〉 d =new Demo〈〉（）；

     泛型类：当类中要操作的引用数据类型不确定的时候，定义泛型进行扩展。

             class utils<QQ>{private QQ q;public void setObject（QQ q）{}}

     泛型方法：不需要提前明确参数类型，直接放在创建对象时。

     -------泛型定义在方法上，可以让不同方法操作不同数据类型。

     注意：public〈T〉void show〈T t〉传什么类型就传什么。  

           同时定义泛型类和泛型方法。泛型方法可以任意。

     特殊之处：静态方法不可以访问静态类上的泛型。〈〉放在返回值类型前面。

     泛型的高级应用：

     当数据类型不确定是〈？〉通配符  也可以定义在方法上

     泛型限定：〈？ extends Person〉可以接受Person类型和Person类型的子类。〈？ super E〉

四、map：

     Map〈k，v〉k-映射所维护的键的类型，v映射值的类型。存储键值对，键要唯一。

     方法：1、获取get（Object key）size、values，

           2、判断containsKey，

           3、添加put（key，value）putAll，

           4、删除clear，remove（Object key）；

     其它重点： entrySet ，keySet   put的同一个key，不同value，

               那么直保留最后一个value，第一个key对应null。

     分类：1、map：HashMap--允许使用null，不同步。常用 ；

           2、HashTable---底层是哈希表数据结构，不可存在key，value为空，同步；

           3、TreeMap--底层是二叉树数据结构，可以给key进行排序 。

     ##Set集合底层就是Map集合。

     keySet：将map所有的键存在Set集合中，迭代取出键，再根据get方法，获取每个键对应的值。

     entrySet：将映射关系存入到Set集合中，这个关系的数据类型为Map.Entry。示例：

                Set.<Map.Entry<String,String>> entrySet =map.entryset()

五、集合框架的工具类：

1、Collections

   概念方法：1、sort--针对list无序进行排序的工具类。不能给set排序。

             2、max--Collections.max(集合)；返回集合中元素最大的元素。

             3、binarySearch--返回角标  

             格式：int index = collcetions.binarySearch(list,"aaa");

    ##   >>1和/2一样。

   Collections2分查找代码： halfSearch     CollectionsDemo（后续加强联系部分）

             4、fill---将集合中德元素全部替换。Colletions.fill(list."pp")。

             5、replaceAll--替换Collections.replaceAll（list，老值，新值）

             6、reverseOrder--反转，集合传入反转比较器。示例：

                TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder());

             7、swap--置换集合里元素位置。Collections.swap(list,1,2);

             8、shuffle--元素重新随机排列。

2Arrays

   概念：用于操作数组的工具类，里面都是静态方法。

   方法：toString---Arrays.String(数组)。数组转换成集合。

   注意：---数组转换成list集合：asList    

         好处：可以用集合的思想和方法操作数组中的元素。但是不可以使用         

         集合的增删方法，因为数组是固定长度的。数组中的元素是基本数据类型，

         那么数组就会变成集合的元素。如果是对象，那么就是数组元素变成集合元素。

   集合变数组：toArray---String[] arr =al.toArray(new String[al.size)]);

   好处：限定对元素的操作。

六、其它--1.5新特性

增强for循环：

    格式：for（数据类型 变量名：被遍历的集合或数组）{}    

    示例：for（String s：al）{syso（s）}

    与传统的区别：高级for必须有被遍历的目标  

    与Iterator区别：迭代器可以进行remove利用ListIterator可以进行着增删。

    对map集合可以先将map转成set集合。set存的是键。

可变参数：

     public static void show（int...arr）{syso（arr.length）;}  main{show(2,4,3,5);}

     注意：可变参数要放在参数列表最后面。

静态导入：

     import static 包。   Collections，Arrays都可以静态导入。