二 Java容器

第二部分.Java容器

一.String

private final char value[]

码工具java8api

1.char charAt(int index); //字符串指定索引的值
2.boolean public boolean endsWith(String suffix)//测试此字符串是否以指定的后缀结尾。
3.boolean equalsIgnoreCase(String anotherString)//忽略大小写
4.
int indexOf(String str)
返回指定子字符串第一次出现的字符串内的索引。
int	indexOf(String str, int fromIndex)
返回指定子串的第一次出现的字符串中的索引，从指定的索引开始。
5.byte[]	getBytes(String charsetName)
使用命名的字符集将此 String编码为字节序列，将结果存储到新的字节数组中。
6.void	getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将此字符串中的字符复制到目标字符数组中
7.String	replace(char oldChar, char newChar)
返回从替换所有出现的导致一个字符串 oldChar在此字符串 newChar 。
8.String	replaceAll(String regex, String replacement)
用给定的替换替换与给定的 regular expression匹配的此字符串的每个子字符串。

9.String	replaceFirst(String regex, String replacement)
用给定的替换替换与给定的 regular expression匹配的此字符串的第一个子字符串。
String	replaceAll(String regex, String replacement)
用给定的替换替换与给定的 regular expression匹配的此字符串的每个子字符串。
String	replaceFirst(String regex, String replacement)
用给定的替换替换与给定的 regular expression匹配的此字符串的第一个子字符串。
String[]	split(String regex)
将此字符串分割为给定的 regular expression的匹配。
String[]	split(String regex, int limit)
将这个字符串拆分为给定的 regular expression的匹配。
boolean	startsWith(String prefix)
测试此字符串是否以指定的前缀开头。
boolean	startsWith(String prefix, int toffset)
测试在指定索引处开始的此字符串的子字符串是否以指定的前缀开头。
CharSequence	subSequence(int beginIndex, int endIndex)
返回一个字符序列，该序列是该序列的子序列。

10.
String	substring(int beginIndex)
返回一个字符串，该字符串是此字符串的子字符串。
String	substring(int beginIndex, int endIndex)
返回一个字符串，该字符串是此字符串的子字符串。
char[]	toCharArray()
将此字符串转换为新的字符数组。
String	toLower[Uppper]Case()
将所有在此字符 String使用默认语言环境的规则，以小写。

11.String	trim()
返回一个字符串，其值为此字符串，并删除任何前导和尾随空格。

字符串实战

1.如何得到字符串包含子字符串的个数，可以采用分割，得到后长度-1，可以采用indexOf（）得到之后重新查找
2.如何看最长子串
先看短的字符串是不是在长的，如果在，则ok，如果不在，则看子字符串-1的子串的长度，则返回
public static String getMaxSubString（String s1, String s2){
	String max=null, min=null;
	max = (s1.length()>s2.length() ? s1 : s2);
	min = max.equals(s1) ? s1 : s2;
	for(int i=0; i<min.length(); i++){
		for(int j=0, k=min.length()-i; k<min.length(); j++, k++){
			String sub = min.substring(a, b);
			if(max.contains(sub)){
				return sub;
			}
		}
	}
	return null;
}

二.数组

1.数组的拷贝

public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
（1）从数组中删除下标为index的某个元素，本质还是数组的拷贝
src, index+1, dest, index, length-index-1
删除第n个元素
src, n, dest, n-1, length-n
最后一个元素置空

2.Arrays工具类

java.util.Arrays

1.static String Arrays.toString(array)//返回指定数组的内容的字符串表示形式。
2.static void Arrays.sort(array)//排序 如果要自己排序，需要实现comparable接口
3.static int Arrays.binarySearch(array, 12);//必须先排序，然后才可以二分查找

3.多维数组

int[][] array = new int[3][]//从低维度到高维度，这个是一维度的

三.包装类

java.lang.Integer

1.parseInt方法和intValue方法

int的最大值
Integer.MAX_VALUE
Integer i = new Integer(i);//可以用于判断NumberFormatException
intValue(),将一个Integer对象转为一个基本数值

2.进制转换

String str = Integer.toBinaryString(6);//进制转换为二进制字符串
十进制->其它进制  
Static String toBinaryString/toHexString/toOctalString(int i)
Static String toString(int i, int scale)
其它进制->十进制
Integer.parseInt(String str, int scale)//其它进制转十进制

3.比较compareTo

Integer a = new Inter(89);
Integer b = new Integer(91);
int a.compareTo(b);//返回1，-1，或者0

4.后面版本

Integer i = 4;

5.实战

（1）缓存Integer的问题

Integer a = new Integer(127);
Integer b = new Integer(127);
Integer x = 128;
Integer y = 128;
a==b false
a.equals(b) true
x==y	//128是分界线，jdk1.5之后自动装箱，如果装箱的是一个字节，那么该数据会被共享，不会重新开辟空间
x.equals(y) true

（2）

四.StringBuffer

​ java.lang.stringbuffer,初始默认是16个字符

​ 就是字符缓冲区，可以存储不同类型的数据,最终要转成字符串使用

1.方法

（1）添加：append
StringBuffer sb = new StringBuffer();
sb.append(1).append(true);
（2）插入： 
sb.insert(int position, Object obj);
sb.insert(1, "hh");
（3）删除：一般要么remove，要么delete
sb.delete(int start, int end);
sb.delete(int index);
（4）查找：
char charAt(index)
int inndexOf(string)
int lastIndexOf(string)
（5）修改：
StringBuffer replace(int start, int end, String str)
void setCharAt(int index, char ch)
（6）设置长度
void setLength(int long)
多的会设置为空
（7）反转
sb.reverse()

（8）sb.toString()

2.StringBuilder不保证同步

五.容器，对象

集合中不可以存储基本数据

java.util.Collection

（1）增：
boolean	add(E e)
确保此集合包含指定的元素（可选操作）。
boolean	addAll(Collection<? extends E> c)
将指定集合中的所有元素添加到此集合（可选操作）。
（2）删：
void clear()
从此集合中删除所有元素（可选操作）。
boolean	contains(Object o)
如果此集合包含指定的元素，则返回 true 。
boolean	containsAll(Collection<?> c)
如果此集合包含指定 集合中的所有元素，则返回true。
boolean	equals(Object o)
将指定的对象与此集合进行比较以获得相等性。
int	hashCode()
返回此集合的哈希码值。
boolean	isEmpty()
如果此集合不包含元素，则返回 true 。
Iterator<E>	iterator()
返回此集合中的元素的迭代器。
default Stream<E>	parallelStream()
返回可能并行的 Stream与此集合作为其来源。
boolean	remove(Object o)
从该集合中删除指定元素的单个实例（如果存在）（可选操作）。
boolean	removeAll(Collection<?> c)
删除指定集合中包含的所有此集合的元素（可选操作）。
default boolean	removeIf(Predicate<? super E> filter)
删除满足给定谓词的此集合的所有元素。
boolean	retainAll(Collection<?> c)//交集
仅保留此集合中包含在指定集合中的元素（可选操作）。
int	size()
返回此集合中的元素数。
default Spliterator<E>	spliterator()
创建一个Spliterator在这个集合中的元素。
default Stream<E>	stream()
返回以此集合作为源的顺序 Stream 。
Object[]	toArray()
返回一个包含此集合中所有元素的数组。
<T> T[]	toArray(T[] a)
返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

1.list

1.1

（1）特有的取出方法，list.get(index)

迭代器只有三个操作

(1).hasNext()
(2).next()
(3).remove()

1.2在迭代过程中不能使用集合操作元素容易造成异常

可以使用Iterator接口的子接口ListIterator来完成迭代中对元素进行更多的操作

ListIterator listit = list.listIterator();
可以在迭代过程中完成对元素的增删改查，只有list具备该迭代功能
还可以逆向迭代

1.3.Vector

内部是数组数据结构，是同步的，线程安全的
有个特殊的方法
Enumeration en = v.elements();
while(en.hasMoreElements()){
	System.out.println(en.nextElement());
}
其它方面没什么特殊的，没有其它作用

1.4ArrayList

内部是数组数据结构，是不同步的

1.5LinkedList

内部是链表数据结构，不同步,主要是各种对头操作
特有的addFirst()
addLast()
pop()//first
push()//first

实战

用LinkedList模拟栈和队列

2.Set

2.1 HashSet

可以自定义哈希算法
先判断哈希值，再判断内容
public hashCOde(int id){
	return id%100;
}
判断值，用哈希表，判断内容，用equals

2.2 TreeSet

自然排序，不是同步

自然排序的比较处理方法

（1）对bean重写compareTo方法

public int compareTO(Object o){
	Person p = (Person)o;
	int temp = this.age - p.age;
	retrun temp==0 ? this.name.compareTo(p.name) : temp;
}

（2）Comparator选择器接口，实现compare方法，在新建Treeset的时候引入

import java.util.Comparator;

public class MyPersonComparator implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		// TODO Auto-generated method stub
		Person p = (Person)o1;
		Person p2 = (Person)o2;
		int temp = p1.getName().compareTo(p2.getName());
		return temp==0 ? p1.getAge() : p2.getAge();
	}
	
}

二叉树，提高效率，查找时候对有序的中间元素查找

3.Map

3.1遍历map

import java.util.*;
 
public class Test{
     public static void main(String[] args) {
      Map<String, String> map = new HashMap<String, String>();
      map.put("1", "value1");
      map.put("2", "value2");
      map.put("3", "value3");
 
      //第一种：普遍使用，二次取值
      System.out.println("通过Map.keySet遍历key和value：");
      for (String key : map.keySet()) {
       System.out.println("key= "+ key + " and value= " + map.get(key));
      }
 
      //第二种
      System.out.println("通过Map.entrySet使用iterator遍历key和value：");
      Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
      while (it.hasNext()) {
       Map.Entry<String, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
 
      //第三种：推荐，尤其是容量大时
      System.out.println("通过Map.entrySet遍历key和value");
      for (Map.Entry<String, String> entry : map.entrySet()) {
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
 
      //第四种
      System.out.println("通过Map.values()遍历所有的value，但不能遍历key");
      for (String v : map.values()) {
       System.out.println("value= " + v);
      }
     }
}

3.2常用方法

1.添加put
	如果原有key，则返回之前关联的值，如果原没有，返回null
2.删除clear
3.判断remove
4.获取

3.3迭代

map没有迭代器

keySet

values

entrySet

Map.Entry<String, String> entry : map.entrySet()

以取，还可以设置，还可以取映射项的哈希值
entry.setValue(V v)

3.4 常用的子类

1.HashTable：内部结构是哈希表，不支持空的键和值，是同步的，下面有一个Properties
2.HashMap：内部结构是哈希表，不是同步的，允许null作为键，值
3.TreeMap：内部结构是二叉树，不同步，可以对map集合键进行排序

六.泛型

1.泛型擦除和泛型补偿

泛型在编译期有用了，编译完成之后会去掉泛型，但是在运行的时候，加入泛型补偿机制，泛型补偿主要是为了适应类加载器

2.问题

TreeSet在使用的时候要比较，排序，当用自己的bean的时候必须要继承Comparble接口，实现compareTo方法，它也带类型

3.泛型类

（1）当类中的操作的引用数据类型不确定的时候，就使用泛型，（2）泛型还可以定义在方法上

public class Tool<QQ>{
	private QQ q;
	public QQ getObject(){
		return q;
	}
	public setObject(QQ object){
		this.q = object;
	}
	public <W> void show(W w){
		System.out.println(w);
	}
}

（3)在静态方法中，由于不能访问类上定义的泛型，如果静态方法使用泛型，只能将泛型定义在方法上

(4)泛型接口

4.？通配符

<? extends Person>：上限
<? super Person>：下限
存的时候用上限，比较器的时候用下限

七.工具类

1.Collection

2.Arrays

asList(List list)方法，把array转成list
（1）数组的长度是固定的，所以转了之后凡是修改长度的，都不能，比如add，remove
（2）如果数组元素是基本类型，转换的时候会将数组整体直接作为一个集合元素存储

3.集合转数组toArray

八.jdk5新特性

1.函数可变参数

public int test(int... arr){
	int sum = 0;
	for(int i=0; i<arr.length; i++){
		sum+=arr[i]
	}
	return sum;
}

2.静态导入

import static java.util.Collections.sort;
sort();

3.System

Properties prop = System.getProperties()
Long t1 = System.currentTimeMillis()//毫秒值

4.Runtime类

Runtime r = Runtime.getRuntime();
r.exec(notepad.exe);