------------- android培训、java培训、java博客、java学习型技术博客、期待与您交流！ --------------
1： String类部分方法
char charAt(int index) 查找index 处的字符
int length() 字符串的长度
char[] toCharArray(); 变成字符数组
int indexOf(String str); str在字符串中第一次出现的位置
boolean endsWith(String str); 判断字符串是否是以str 结尾
String[] split(String reg); 用正则或者字符串来分割字符串
String substring(int index); 从index 到末尾的子串
String(char[] arr); 用字符数组变成字符串。
实例：获取一个字符串在另一个字符中出现的次数：
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; }实例2： 获取两个字符串中最大相同的子串：
思路：
1，将短的那个子串按照长度递减的方式获取到。
2，将每获取到的子串去长串中判断是否包含，如果包含，已经找到！。
public static String getMaxSubString(String s1,String s2) { String max = "",min = ""; max = (s1.length()>s2.length())?s1: s2; min = (max==s1)?s2: s1; for(int x=0; x<min.length(); x++) { for(int y=0,z=min.length()-x; z!=min.length()+1; y++,z++) { String temp = min.substring(y,z); System.out.println("temp"); if(max.contains(temp)) return temp; } } return ""; }
2： StringBuffer
字符串的组成原理就是通过该类实现的。
StringBuffer可以对字符串内容进行增删。
StringBuffer是一个容器。
很多方法与String相同。
StingBuffer是可变长度的。
特有方法：
StringBuffer append(int x);
StringBuffer delete(int start, int end );
StringBuffer insert(int index,String str);
StringBuffer reverse();
JDK1.5出现一个StringBuilder，区别是 StringBuffer是同步的，StringBuilder是非同步 的。
3： 集合框架的构成及分类
Collection接口有两个子接口：
List（列表），Set（集）
List：可存放重复元素，元素存取是有序的。
Set：不可以存放重复元素，元素存取是无序 的。
Collection提供的方法：
1，添加
add(e);
addAll(collection);
2，删除
remove(e);
removeAll(collection);
clear();
3，判断。
contains(e);
isEmpty();
4，获取
iterator();
size();
5，获取交集。
retainAll();
6，集合变数组。
toArray();
List接口中常用类
Vector：线程安全，但速度慢，已被 ArrayList替代。
ArrayList：线程不安全，查询速度快。
LinkedList：链表结构，增删速度快。
ArrayList：实质就是一个会自动增长的数组
查询效率比较高，增删的效率比较低，适用于查询比较频繁，增删动作较少的元素管理的集合。
加载大批量的数据时，先进行手动扩容(就是调用ensureCapacity(int minCapacity)方法)，这样可以提高效率。
LinkedList：底层是用双向循环链表来实现的
查询效率低，但是增删效率很高，适用于增删动作的比较频繁，查询次数较少的元素管理的集合
取出List集合中元素的方式：
•get(int index)：通过脚标获取元素。
•iterator()：通过迭代方法获取迭代器对象。
迭代：
迭代是取出集合中元素的一种方式。
因为Collection中有iterator方法，所以每一个 子类集合对象都具备迭代器。
用法：
Iterator iter = l.iterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}
迭代注意事项
迭代器在Collcection接口中是通用的，它替 代了Vector类中的Enumeration(枚举)。
迭代器的next方法是自动向下取元素，要避 免出现NoSuchElementException。
迭代器的next方法返回值类型是Object，所 以要记得类型转换。
Set接口中常用的类：
HashSet：线程不安全，存取速度快。
Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复TreeSet：线程不安全，可以对Set集合中的 元素进行排序
HashSet
底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是如何保证元素唯一性的呢？是通过元素的两个方法，hashCode和equals来完成。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashcode值不同，不会调用equals。注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。/* 往hashSet集合中存入自定对象 姓名和年龄相同为同一个人，重复元素。 */ 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)); hs.add(new Person("a4",14)); 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; } }
TreeSet：
可以对Set集合中的元素进行排序。底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法return 0.
TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。也种方式也成为元素的自然顺序，或者叫做默认顺序。
TreeSet的第二种排序方式。当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。在集合初始化时，就有了比较方式。
TreeSet 例子：
需求：往TreeSet集合中存储自定义对象学生。想按照学生的年龄进行排序。
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) { 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; } }
Comparable接口：
也叫做可比较接口，这个接口在java.lang包下，只要根据指定类型的排序规则实现了这个接口，就是可排序的。
这个接口中只定义了一个 compareTo(Object o) 方法，该方法的返回值类型是整型，如果当前对象大于参数对象就返回正数，当前对 象等于参数对象就返回0，当前对象小于参数对象就返回负值，这样写就是升序排列，反之则是进行降序排列。
Comparator接口：
比较器Comparator接口，是另一种对自定义类型对象的集合整体排序的方法，存在于java.util包下。
这个接口中定义了一个 compare(Object o1,Object o2) 方法来比较两个对象，这个方法的返回值定义和上面介绍的那个方法是一样。
利用这种方式，则在创建集合的时候把定义好的比较器作为参数，构造一个集合
Set集合元素唯一性原因：
HashSet：通过equals方法和hashCode 方法来保证元素的唯一性。
TreeSet：通过compareTo或者compare 方法中的来保证元素的唯一 性。元素是以二叉树的形式存 放的。
4： 泛型的特点：
提高了程序的安全性
将运行期遇到的问题转移到了编译期
省去了类型强转的麻烦
泛型类的出现优化了程序设计
5： Map与Collection
Map与Collection在集合框架中属并列存在
Map存储的是键值对
Map存储元素使用put方法，Collection使用 add方法
Map集合没有直接取出元素的方法，而是 先转成Set集合，在通过迭代获取元素
Map集合中键要保证唯一性
6: Map集合常用类
Hashtable：线程安全，速度慢，不允许存放 null键，null值，已被HashMap替代。
HashMap：线程不安全，速度快，允许存放null 键，null值。
TreeMap：对键进行排序，排序原理与TreeSet 相同。
Map：存放key-value对(有关系的两个对象，一个做key，一个做value，同时存入)
HashMap：基于哈希表的 Map 接口的实现，此实现提供所有可选的映射操作，并允许使用 null 值和 null 键
遍历：
先调用keySet()得到key的set集合，
再迭代遍历key的set集合，
根据key得到value。
Hashtable：同HashMap，一般不使用
HashMap与Hashtable的区别：
HashMap：非线程安全，不支持并发控制，允许空的键值对。
Hashtable：是线程安全，支持并发控制，不允许有空的键值对。
SortedMap接口：Map的子接口，按某一特定排序规则来存放所加入的键值对
实现类：TreeMap类。
Key值的排序规则，同SortedSet接口实现类TreeSet
注意：
key一般是8种基本类型的封装类或者是String类，拿自己自定义的类作为Key没有意义。
key不可重复，value可以重复
1，添加。 put(K key, V value) putAll(Map<? extends K,? extends V> m) 2，删除。 clear() remove(Object key) 3，判断。 containsValue(Object value) containsKey(Object key) isEmpty() 4，获取。 get(Object key) size() values() entrySet() keySet()
map集合两种取出方式：
1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。
所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。
//先获取map集合的所有键的Set集合,keySet(); Set<String> keySet = map.keySet(); //有了Set集合。就可以获取其迭代器。 Iterator<String> it = keySet.iterator(); while(it.hasNext()) { String key = it.next(); //有了键可以通过map集合的get方法获取其对应的值。 String value = map.get(key); System.out.println("key:"+key+",value:"+value); }
2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：Map.Entry
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢？
因为只有有了Map集合，有了键值对，才会有键值的映射关系。
关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。
//将Map集合中的映射关系取出。存入到Set集合中。 Set<Map.Entry<String,String>> entrySet = map.entrySet(); Iterator<Map.Entry<String,String>> it = entrySet.iterator(); while(it.hasNext()) { Map.Entry<String,String> me = it.next(); String key = me.getKey(); String value = me.getValue(); System.out.println(key+":"+value); }
7; 集合框架中的工具类
Collections
•对集合进行查找
•取出集合中的最大值，最小值
•对List集合进行排序
Arrays
•将数组转成List集合
•对数组进行排序
•对数组进行二分查找
8： 取出ArrayList 中的重复元素。应用一
class ArrayListTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("<span style="font-family:Arial,Helvetica,sans-serif">java00</span>");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java01");
System.out.println(al);
al = singleElement(al);
<pre name="code" class="java"> System.out.println(al);<span style="font-family:Arial,Helvetica,sans-serif; font-size:12px"> </span>
9: ArrayList 应用二
import java.util.*;
/*
将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。
思路：
1，对人描述，将数据封装进人对象。
2，定义容器，将人存入。
3，取出。
List集合判断元素是否相同，依据是元素的equals方法。
*/
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class ArrayListTest2
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add(new Person("lisi01",30));
al.add(new Person("lisi02",32));
al.add(new Person("lisi04",35));
al.add(new Person("lisi01",30));
<pre name="code" class="java"> //remove方法底层也是依赖于元素的equals方法10： 用LinkedList实现队列 先进先出
import java.util.*;
class DuiLie
{
private LinkedList link;
DuiLie()
{
link = new LinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj);
}
public Object myGet()
{
return link.removeFirst();
}
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[] args)
{
DuiLie dl = new DuiLie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
while(!dl.isNull())
{
System.out.println(dl.myGet());
}
}
}
11： Vector 的应用实例
class VectorDemo { public static void main(String[] args) { Vector v = new Vector(); v.add("java01"); v.add("java02"); v.add("java03"); v.add("java04"); Enumeration en = v.elements(); while(en.hasMoreElements()) { System.out.println(en.nextElement()); } } }
12：TreeSet 的应用实例
字符串本身具备比较性。但是它的比较方式不是所需要的。 这时就只能使用比较器。 import java.util.*; class TreeSetTest { public static void main(String[] args) { TreeSet ts = new TreeSet(new StrLenComparator()); ts.add("abcd"); ts.add("cc"); ts.add("cba"); ts.add("aaa"); ts.add("z"); ts.add("hahaha"); Iterator it = ts.iterator(); while(it.hasNext()) { System.out.println(it.next()); } } } class StrLenComparator implements Comparator { public int compare(Object o1,Object o2) { String s1 = (String)o1; String s2 = (String)o2; int num = new Integer(s1.length()).compareTo(new Integer(s2.length())); if(num==0) return s1.compareTo(s2); return num; } }
13: HashMap 的应用实例
/* 每一个学生都有对应的归属地。 学生Student，地址String。 学生属性：姓名，年龄。 注意：姓名和年龄相同的视为同一个学生。 保证学生的唯一性。 1，描述学生。 2，定义map容器。将学生作为键，地址作为值。存入。 3，获取map集合中的元素。 */ import java.util.*; class Student implements Comparable<Student> { private String name; private int age; Student(String name,int age) { this.name = name; this.age = age; } public int compareTo(Student s) { int num = new Integer(this.age).compareTo(new Integer(s.age)); if(num==0) return this.name.compareTo(s.name); return num; } public int hashCode() { return name.hashCode()+age*34; } public boolean equals(Object obj) { if(!(obj instanceof Student)) throw new ClassCastException("类型不匹配"); Student s = (Student)obj; return this.name.equals(s.name) && this.age==s.age; } public String getName() { return name; } public int getAge() { return age; } public String toString() { return name+":"+age; } } class MapTest { public static void main(String[] args) { HashMap<Student,String> hm = new HashMap<Student,String>(); hm.put(new Student("lisi1",21),"beijing"); hm.put(new Student("lisi1",21),"tianjin"); hm.put(new Student("lisi2",22),"shanghai"); hm.put(new Student("lisi3",23),"nanjing"); hm.put(new Student("lisi4",24),"wuhan"); //第一种取出方式 keySet Set<Student> keySet = hm.keySet(); Iterator<Student> it = keySet.iterator(); while(it.hasNext()) { Student stu = it.next(); String addr = hm.get(stu); System.out.println(stu+".."+addr); } //第二种取出方式 entrySet Set<Map.Entry<Student,String>> entrySet = hm.entrySet(); Iterator<Map.Entry<Student,String>> iter = entrySet.iterator(); while(iter.hasNext()) { Map.Entry<Student,String> me = iter.next(); Student stu = me.getKey(); String addr = me.getValue(); System.out.println(stu+"........."+addr); } } }
14: TreeMap 的应用实例：
/* 需求：对学生对象的年龄进行升序排序。 因为数据是以键值对形式存在的。 所以要使用可以排序的Map集合。TreeMap。 */ import java.util.*; class StuNameComparator implements Comparator<Student> { public int compare(Student s1,Student s2) { int num = s1.getName().compareTo(s2.getName()); if(num==0) return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); return num; } } class MapTest2 { public static void main(String[] args) { TreeMap<Student,String> tm = new TreeMap<Student,String>(new StuNameComparator()); tm.put(new Student("blisi3",23),"nanjing"); tm.put(new Student("lisi1",21),"beijing"); tm.put(new Student("alisi4",24),"wuhan"); tm.put(new Student("lisi1",21),"tianjin"); tm.put(new Student("lisi2",22),"shanghai"); Set<Map.Entry<Student,String>> entrySet = tm.entrySet(); Iterator<Map.Entry<Student,String>> it = entrySet.iterator(); while(it.hasNext()) { Map.Entry<Student,String> me = it.next(); Student stu = me.getKey(); String addr = me.getValue(); System.out.println(stu+":::"+addr); } } }
------------ android培训、java培训、java博客、java学习型技术博客、期待与您交流！ -------------
详情请查看：http://edu.youkuaiyun.com/heima/
扫一扫
1686
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
