Java-容器

[1]String类,不可继承
字符串是一个特殊的对象
字符串一但初始化就不可以被改变

String str ="abc" 与 String str1 = new String("abc");有什么区别 ？
//
str在内存中有一个对象。//str是一个类类型变量，"abc"是一个对象
str1在内存中有两个对象。// "abc"是一个对象。又 new 出了一个string 对象
//
str.equals(str1) --> true (比较内存地址)
//String类复写了Object类中的equals方法，该方法用于判断字符串内容是否相同
str == str1 -->false
//
String s1 ="abc";
String s2 = new String("abc");
String s3 ="abc";

s1 == s3 --> true;

[2]String的方法
String类适用于描述字符串事物，它提供了多了方法对字符串进行操作。
1.获取
a.字符串长度
str.length(); //与之区别的是数组的长度，arr.length ,不过这是arr的属性
b.根据位置获取位置上某个字符
int charAt(int index)
c.根据字符获取该字符在字符串中的位置
int indexof(int ch)返回ch首次出现的位置
int indexof(String str)返回str首次出现的位置
int indexof(int ch,int formIndex)从formIndex指定的位置开始找
int lastindexof(int ch)反向索引返回ch首次出现的位置
2.判断
a.字符串中是否包含某一个子串
boolean contains(CharSequence s);
特殊之处：
intdexOf(str):可以索引str第一次出现的位置。如果返回 -1，表示该
str不存在与子符串中。所以intdexOf也可以判断是否包含某一个子串。
如果只需要判断用contains，如果先判断又拿位置用intdexOf
b.字符串是否有内容
boolean isEmpty(Sring str)
c.字符串是否以指定内容开头
boolean startWith(Sring str)
d.字符串是否已指定内容结尾
boolean endWith(Sring str)
e.判断字符串内容是否相同。复写了Object类中的equals方法
boolean equals(str)
f.判断内容是否相同，并忽略大小写
boolean equalsIgnoreCase()
3.转换
a.字符数组转字符串
构造函数:String(char[])
String(char[],offset,count)一部分转为字符串从offset开始的count个字符
静态方法：
static String copyValueof(char[])
static String copyValueof(char[],offset,count)
static String valueOf(char[])
b.字符数串转字符数组
char[] toCharArray();
c.字节数组转字符串
构造函数:String(byte[])
String(byte[],offset,count)一部分转为字节串从offset开始的count个字符

d.字符串组转字节数组
byte[] getBytes();
字符串和字节数组在转换过程中，可以指定编码表
f.基本数据类型转字符串
static String valueOf(int)
static String valueOf(double)
4.替换
String replace(char oldchar,char newchar)
5.切割
String[] split(char regex)
6.子串。获取字符串中的一部分
String subString(int begin,int end)
7.转换，去除空格，比较
a.转大写
String toUpperCase()
b.转小写
String toLowerCase()
c.去除前后空格
String trim();
d.对两个字符串进行自然顺序的比较
int comareTo(String) - 0 + 返回不相等处char1与char的差

[3]StringBuffer的方法
字符串的组成原理就是通过该类实现的
StringBuffer可以对字符串内容进行增删
StringBuffer是一个容器，与String有很多相同的方法，
不过StringBuffer是可变长度的

1.存储
append()添加数据到尾部
insert(index,数据)
2.删除
delete(start,end) 删除包含star至end的数据，不包含end
deleteCharAt(index) 删除指定位置字符
3.获取
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length()
String subString(start,end)
4.修改
replace(start,end,string)
void setCharAt(index,ch)替换一个字符，返回void
5.反转
reverse()
6.getchars(int srcBegin,int srcEnd,char[] dst,int dstBegin)
srcBegin:从哪里开始
srcEnd:从哪里结束
dst:存在哪里
dstBegin:存在哪个位置开始

StringBuffer与StringBuilder
StringBuffer:线程同步
StringBuilder:线程不同步(JDK1.5出现)

[4]基本数据类型包装类

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

基本数据类型对象包装类的最常见作用
就是用于基本数据类型和字符串之间做转换。

基本数据类型转成字符串

基本数据类型+"";
基本数据类型.ToString();

Integer.toString(34)

字符串转成基本数据类型
基本数据类型.paseXXX()
int num = Integer.paseInt("123");

比较

Integer x = new Integer("123");
Integer y = new Integer("123");

x==y -->false
x.equals(y) -->true

[5]基本数据类型包装类的装箱与拆箱

Integer x = 3；
x = x + 2; //x先拆箱与2相加，相加后的结果装箱
Integer y = null；
y.equals(x) //运行错误y为null，即使可以编译通过

Integer x1 = 128；
Integer y1 = 128；

x1 == y1 --> false

Integer x2 = 128；
Integer y2 = 128；

x2 == y2 --> true
//这是因为x2和y2指向了同一个对象。当数值在byte范围内时，对于新特新，如果该数
值已存在，则不会开辟空间

[6]集合类

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

数组和集合类同是容器，有何不同
数组虽然也可以存储对象，但数组长度是固定的。
数组可以存储基本数据类型，但集合只能存储对象。

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

每个容器对数据的存储方式不一样。

Collection
List Set
ArrayList LinkedList Vector HashSet TreeSet

Collection包含的方法：
add()
addAll()
clear()
remove()
removeAll()
contains() 包含
containsAll()
equals()
isEmpty()
size() size() ==0 为空
retainAll() 交集
toArray()
iterator() 取出 返回值是一个迭代器

Iterator it= arr.iterator();//获取迭代器，用于取出集合中的元素
while(it.haxNext()){
it.next();
}

什么是迭代器
其实迭代器就是取出集合元素的方式
Iterator//迭代过程中不可修改
for(Iterator it = arr.iterator();it.haxNext(); ){
it.next()
}
//迭代器使用完之后it对象已经没用，使用for循环可以节省内存

Collection
|--List：元素是有序的，元素可重复，因为集合体系有索引
|--Set ：元素是无序的，元素不可重复。

List：特有的方法
增：add(index,element);
addAll(index,Collection)
删：remove(index)
改：set(index,element)
查：get(index)
subList(from,to)
listIterrator()

；List集合特有的迭代器，ListIterator是Iterator的子接口，
在迭代时，不可该表集合中的元素，改变后会发生并发异常，
所以在迭代器迭代时，只能通过迭代器的方法操作元素Iterator接口的方法是有限的。
只能是判断、取出操作。其他操作需要使用其子接口的迭代器，ListIterator。
ListIterator 只能通过list.interator()获取

ListIterator:有一个新的方法： previous，倒着取元素

Collection
|--List：元素是有序的，元素可重复，因为集合体系有索引
|--ArrayList:底层的数据结构使用的书数组结构。特点：查询速度快，增减速度慢，线程不同步。
|--LinkedList：底层使用的数据结构是链表。特点：增删速度快，查询稍慢。
|--Vector：底层是使用的数据结构是数组。线程同步，被ArrayList替代了 (Enumeration 是vector特有的)

LinkedList：特有的方法
addFirst
addLast
getFirst
getLast
获取元素，不删除
removeFirst
获取元素，并删除
removeLast

pollFirst

Collection
|--Set：元素是无序的，元素不可重复。(Set的功能和Conllection是一致的)
|--HashSet ：底层的数据结构是hash表，线程是非同步的。
HashSet是如何保证元素唯一性的呢?
是通过hashcode和equals方法来完成的。
如果元素的hashcode值相同，才会判断equals是否为true
如果元素的hashcode值不同，不会调用equals。
注意，对于元素是否存在或删除等操作，依赖的方法是的hashcode、equals。
|--TreeSet ：元素是无序的，元素不可重复。
可以对Set集合中的元素进行排序。
底层数据结构是二叉树
保证元素唯一性的依据：
compareTo方法return 0
TreeSet排序的方式：
1.让元素自身具备比较性。元素类需要实现 Comparable接口和重写compareTo方法
这种方式也成为元素的自然顺序，或者叫做默认顺序。
2.当元素不具备比较性是，或者具备的比较性不是所需要的。
这时需要让集合自身具备比较性。在集合初始化时，就有了比较方式。
定义一个类，实现 Comparable接口和重写compare方法
当两种排序都存在时，以比较器为主。

[7]泛型
泛型，1.5以后出现的新特性。用于解决安全问题。是一个类型安全机制。
好处：
1.将运行实现出现的CalssCastException，转移到了编译时期。方便于程序员解决问题。
让运行时期问题减少。

2.避免了强制转换的麻烦。

泛型的格式：通过尖括号<>来定义要操作的引用数据类型。
在使用java提供的对象是，什么时候写泛型呢?
通常在集合框架很常见，只要碰到尖括号，就要定义泛型。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

//泛型定义在类上

什么时候定义泛型类？
在类中要操作的引用数据类型不确定的时候，早起用Object来完成扩展，
现在用泛型来完成扩展。

泛型类定义的泛型，在这个类中有效。如果方法被使用。那么泛型类的对象明确
的操作的具体类型后，所要操作的类型就已经固定了。

//泛型定义在方法上
为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。

//泛型定义在静态方法上
静态方法不可以访问类上定义的泛型，
如果静态方法操作的应用数据类型不确定，可以将泛型定义在静态方法上。

pbulic static <T> void method(T t);{
}
//泛型定义正在接口

//泛型限定 <? extends Class>
? 通配符，占位符。
泛型的限定
? extends E： 可以接收E类型或者E的子类型，上限
? super E : 可以接收E类型或者E的父类型， 下限

[8]Map<K,V>
map集合的基本特点，该集合存储键值对，一对一对的存储，而且必须保证键的唯一性。

Map
|--Hashtable:底层是哈希表数据结构，可以不可以存入null键null值，该集合是线程同步的。
|--HashMap：底层是哈希表数据结构，允许使用null值和null键，该集合是不同步的，将HashTable覆盖，
|--TreeMap：底层是二叉树数据结构，线程不同步，可以用map集合中的键进行排序

map和set很像，其实set底层就是使用了map集合。

map集合的两种取出方式：
1.Set<K> keySet：将map中所有的键存入到set集合，因为set集合具备迭代器，
所以可以用迭代方式取出所有的键，再根据get方法，获取每一个键对英国的值。
2.Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到set集合中，
而这个关系的数据类型就是Map.Entry。

//将map集合中的映射关系取出，并存入都Set集合中。

[9]Collections 集合框架的工具类
sort()排序
max()取最大值
binarySearch()//二分法查找
fill替换
reverseOrder逆向反转
SynList

[10] Arrays 数组的工具类
数组变集合的方法 Arrays.asList(arr);

把数组变成list集合有什么好处，
可以使用集合的思想和方法来操作数组中的元素
注意：数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。
如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素、
如果数组中的元素都是基本数据类型，那么该数组作为集合中的元素存在。
[11] 集合边数组
指定类型的数组到底要定义多长呢，
当指定类型的数组长度小于集合的size，那么该方法会创建一个新的数组，长度为
集合的size。
当指定类型的数组长度大于集合的size，那么不会创建数组，而是使用传递进来的数组。
所以创建一个刚刚好的数组最优
String[] arr = arrayList.toArray(new String[arrayList.size]);

为什么要将集合变数组?
是因为要限定对元素的操作。
[12]增强型for
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{

}
for和迭代器的区别
for 对集合进行遍历。但只能获取集合元素，不能对集合进行操作。

迭代器对集合除了遍历，还可以进行remove集合汇总的动作。
如果使用ListIteratot，还可以在遍历过程中对集合进行增删改查的动作。

传统for和高级for有什么区别
高级for有一个局限性，必须有被遍历的目标。

[13] 可变参数
可变参数就是一种数组参数的简写形式，不用每一次都手动建立数组对象，
只要将要操作的元素作为参数传递即可。
使用时要将可变参数放至函数参数列表的最后。
public static void Main(String args){
show("hehe",4);
show("hehe",1,2,3,4,4);
show("hehe",1,3,4);
show("hehe");
}

public void show(String str,int... arr){
System.out.println(arr.length);
}

[14] 静态导入 StaticImport

import static java.lang.System.*;//导入了System类中所有静态成员。