PDFjava笔记

Eclipse背景颜色 85,123，205


package com.yuan.cn;
//给定一个数字，按字典排序
public class StringTest_1 {
    public static void main(String[] args){
        String[] arr = {"nba","abc","cba","zz","qq"};
        printArray(arr);
        sortString(arr);
        printArray(arr);
        
    }
    public static void sortString(String[] arr){
        for(int i = 0;i < arr.length;i++){
            for(int j = i + 1;j < arr.length;j++){
                if(arr[i].compareTo(arr[j]) > 0){
                    swap(arr, i, j);
                }
            }
        }
    }
    public static void swap(String[] arr,int i,int j){
        String temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    public static void printArray(String[] arr){
        System.out.println("[");
        for(int i = 0;i < arr.length;i++){
            if(i != arr.length-1){
                System.out.println(arr[i] + ",");
            }else {
                System.out.println(arr[i] + " ] ");
            }
        }
    }
}

package com.yuan.cn;
//，一个子串在整中出现的次数。
public class StringTest_2 {
    public static void main(String[] args) {
        String str = "nbasjdsdhjnbakflnbajjfhnba";
        String key = "nba";
        int count = getKeyStringCount(str, key);
        System.out.println("count=" + count);
    }
    public static int getKeyStringCount_2(String str,String key){
        int count = 0;
        int index = 0;
        while((index = str.indexOf(key,index)) != -1){
            index = index + key.length();
            count++;
        }
        return count;
    }
    //获取子串在整中出现的次数。
    public static int getKeyStringCount(String str,String key){
        //1.定义计数器
        int count = 0;
        //2.定义变量记录key出现的位置
        int index = 0;
        while((index = str.indexOf(key)) != -1){
            str = str.substring(index + key.length());
            count++;
        }
        return count;
         }
    }


package com.yuan.cn;
//，两个字符串中最大相同的子。
public class StringTest_3 {
    public static void main(String[] args) {
        String s1 = "qwerabcdtyuiop";
        String s2 = "xcabcdvbn";
        String s = getMaxSubstring(s1, s2);
        System.out.println("s=" + s);
    }
    //获得最大子串
    public static String getMaxSubstring(String s1,String s2){
        String max = null;
        String min = null;
        max = (s1.length()>s2.length())?s1:s2;
        min = max.equals(s1)?s2:s1;
        System.out.println("max=" + max);
        System.out.println("min=" + min);
        for(int i = 0;i < min.length();i++){
            for(int a = 0,b = min.length()-i;b != min.length()+1;a++,b++){
                String sub = min.substring(a,b);
                System.out.println(sub);
                if(max.contains(sub)){
                    return sub;
                }
            }
        }
        
        return null;
        
    }
}


StringBuffer及其方法使用
 1，长度的可变的。2，可以存储不同类型数据。3，最终要转成字符串进行使用。 4，可以对字符串进行修改。
1，添加：
 StringBuffer append(data);
 StringBuffer insert(index,data);
2.删除：
* StringBuffer delete(start,end):包含头，不包含尾。
* StringBuffer deleteCharAt(int index):删除指定位置的元素
3，查找：
* char charAt(index);
* int indexOf(string);
* int lastIndexOf(string);
4，修改：
* StringBuffer replace(start,end,string);
* void setCharAt(index,char);
*
* 增删改查 C(create)U(update)R(read)D(delete

StringBuilder使用
不同的是：
* StringBuffer是线程同步的。通常用于多线程。
* StringBuilder是线程不同步的。通常用于单线程。 它的出现提高效率。

包装类及方法使用：
基本类型--->字符串
* 1,基本类型数值+""
* 2,用String类中的静态方法valueOf(基本类型数值);
* 3,用Integer的静态方法valueO(基本类型数值);
*
* 字符串--->基本类型
* 1,使用包装类中的静态方法 xxx parseXxx("xxx类型的字符串");*****
* int parseInt("intstring");
* long parseLong("longstring");
* boolean parseBoolean("booleanstring");
* 只有Character没有parse方法
* 2,如果字符串被Integer进行对象的封装。
* 可使用另一个非静态的方法，intValue();
* 将一个Integer对象转成基本数据类型值。

十进制-->其他进制。
* toBinaryString
* toOctalString
* toHexString
其他进制-->十进制。
* parseInt("string",radix)

迭代器的使用：
Iterator it = coll.iterator();
     while(it.hasNext()){
     System.out.println(it.next());
        }

Enumeration en = v.elements();
while(en.hasMoreElements()){
    System.out.println("nextelment:"+en.nextElement());
}
Iterator it = v.iterator();
while(it.hasNext()){
    System.out.println("next:"+it.next());
}

三个方法，hashCode(),equals(),toString()

集合（List、Set）部分总结：
集合类的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。
就使用集合容器进行存储。
集合特点：
    1，用于存储对象的容器。
    2，集合的长度是可变的。
    3，集合中不可以存储基本数据类型值。
    集合容器因为内部的数据结构不同，有多种具体容器。
    不断的向上抽取，就形成了集合框架。
    框架的顶层Collection接口：
Collection的常见方法：
    1，添加
        boolean add(Object obj):
        boolean addAll(Collection coll)
    2，删除。
        boolean remove(object obj):
        boolean removeAll(Collection coll);
        void clear();
3，判断：
        boolean contains(object obj):
        boolean containsAll(Colllection coll);
        boolean isEmpty():判断集合中是否有元素。
4，获取：
    int size():
    Iterator iterator():取出元素的方式：迭代器。
    该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。
    所以该迭代器对象是在容器中进行内部实现的。
    对于使用容器者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器的对象即可，
    也就是iterator方法。
    Iterator接口就是对所有的Collection容器进行元素取出的公共接口。

5，其他：
    boolean retainAll(Collection coll);取交集。
    Object[] toArray():将集合转成数组。
Collection
    |--List：有序(存入和取出的顺序一致),元素都有索引(角标)，元素可以重复。
    |--Set：元素不能重复,无序。

List:特有的常见方法：有一个共性特点就是都可以操作角标。
    1，添加
        void add(index,element);
        void add(index,collection);
    2，删除；
        Object remove(index);
    3，修改：
        Object set(index,element);
    4，获取：
        Object get(index);
        int indexOf(object);
        int lastIndexOf(object);
        List subList(from,to);
list集合是可以完成对元素的增删改查。

List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。
|--LinkedList:内部是链表数据结构，是不同步的。增删元素的速度很快。

LinkedList:
addFirst();
addLast():
jdk1.6
offerFirst();
offetLast();
getFirst();.//获取但不移除，如果链表为空，抛出NoSuchElementException.
getLast();
jdk1.6
peekFirst();//获取但不移除，如果链表为空，返回null.
peekLast():
removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.
removeLast();
jdk1.6
pollFirst();//获取并移除，如果链表为空，返回null.
pollLast();

Set:元素不可以重复，是无序。
Set接口中的方法和Collection一致。
|--HashSet: 内部数据结构是哈希表 ，是不同步的。
    如何保证该集合的元素唯一性呢？
    是通过对象的hashCode和equals方法来完成对象唯一性的。
    如果对象的hashCode值不同，那么不用判断equals方法，就直接存储到哈希表中。
    如果对象的hashCode值相同，那么要再次判断对象的equals方法是否为true。
    如果为true，视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。
记住：如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
一般情况下，如果定义的类会产生很多对象，比如人，学生，书，通常都需要覆盖equals，hashCode方法。
建立对象判断是否相同的依据。

|--TreeSet:可以对Set集合中的元素进行排序。是不同步的。
判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元就需要实现Comparable接口。覆盖compareTo方法。
如果不要按照对象中具备的自然顺序进行排序。如果对象中不具备自然顺序。怎么办？
可以使用TreeSet集合第二种排序方式二：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
将该类对象作为参数传递给TreeSet集合的构造函数。
if(this.hashCode()== obj.hashCode() && this.equals(obj))
哈希表确定元素是否相同
1，判断的是两个元素的哈希值是否相同。
如果相同，在判断两个对象的内容是否相同。
2，判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是equals方法。
注意：如果哈希值不同，是不需要判断equals。

TreeSet和比较方法（实现Comparator接口）使用
比较的另一种方法即让对象实现Comparable接口，即让对象本身具备可比较性并重写compareTo（）
方法，实际上就是改发return表达式，但不如实现Comparator接口迚行比较更为灵活，