数组是具有相同的数据类型且按一定次序排列的一组变量的集合体
一维数组：连续内存的，线性的，有下标的，长度固定的
动态数组: 连续内存的，线性的，有下标的 ，长度可变的
说到动态数组 那么不如自己定义一个
public class DynamicArray2<E> {
int rongliang = 10;// 容量
int bilv = 10;// 增长比率
Object[] src = new Object[rongliang];
public DynamicArray2(){
}
public DynamicArray2(int rongliang, int bilv) {
this.rongliang = rongliang;
this.bilv = bilv;
Object[] src = new Object[rongliang];
}
// 三个新概念
// 容量，增长比率，可变数组长度（元素个数）
// 定义一个原始数组
/**
* 查找数组中第一个为null的位置下标
*
* @return
*/
private int getNullIndex() {
for (int i = 0; i < src.length; i++) {
if (src[i] == null) {
return i;
}
}
return -1;
}
/**
* 将指定元素放入数组
*
* @param s
* 要放入的元素内容
*/
public void add(E s) {
// 如果长度<容量，不需要新数组
if (size() >= src.length) {
// 定义一个新数组，长度是原始数组长度+1
Object[] dest = new Object[src.length + bilv];
// 将原始数组中的数据考入新数组
for (int i = 0; i < src.length; i++) {
dest[i] = src[i];
}
// 将src指向新数组
src = dest;
}
int index = getNullIndex();
src[index] = s;
}
/**
* 根据下标取出元素
*
* @param index
* 要取出的元素的下标
* @return 返回取得的元素
*/
public E get(int index) {
if (index < 0 || index >= size()) {
throw new RuntimeException("给定的index超出范围:size:" + size()
+ ",index:" + index);
}
E s = (E)src[index];
return s;
}
/**
* 获得数组中的元素个数 返回数组中连续的不为null的元素个数
*
* @return 返回获得的元素个数
*/
public int size() {
int count = 0;
for (int i = 0; i < src.length; i++) {
if (src[i] != null) {
count++;
} else {
break;
}
}
return count;
}
/**
* 将指定的元素放入指定的位置
*
* @param s
* 要放入的元素
* @param index
* 元素所在的位置
*/
public void insert(E s, int index) {
if (size() >= src.length) {
// 定义一个新数组，长度是原始数组长度+1
Object[] dest = new Object[src.length + bilv];
// 将原始数组中的数据考入新数组
for (int i = 0; i < src.length; i++) {
dest[i] = src[i];
}
// 将src指向新数组
src = dest;
}
for(int i=size();i>index;i--){
src[i]=src[i-1];
}
src[index]=s;
}
/**
* 修改指定位置的元素
*
* @param s
* 修改后的新元素
* @param index
* 元素的位置
*/
public void modify(E s, int index) {
src[index] = s;
}
/**
* 删除指定位置的元素
*
* @param index
* 要删除的元素的位置
* @return 返回被删除的元素
*/
public E delete(int index) {
E e = (E)src[index];
for(int i=index;i<size();i++){
src[i] =src[i+1];
}
return e;
}
/**
* 删除指定的元素
*
* @param s
* 要删除的元素
*/
public void delete(E s) {
int index = -1;
for (int i = 0; i < src.length; i++) {
if (src[i].equals(s)) {
index = i;
break;
}
}
delete(index);
}
}
在java 中 已经为我们定义了集合框架（接口） Collection
Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。
Set 不允许重复元素的一组数据集合 无下标 无序
HashSet TreeSet
List 允许重复元素 带下标 有序
ArrayList
HashSet:
此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。
将数据放入HashSet中
public static void hashSetDemo() {
// 创建集合对象
HashSet<String> set = new HashSet<String>();
// 放入元素
for (int i = 0; i < 10; i++) {
String s = "张三" + i;
set.add(s);
}
set.add("李四");
boolean b = set.add("李四");
System.out.println(b);
boolean b2 = set.contains("李四");
System.out.println(b2);
// 取出元素，使用迭代器
// Iterator<String> iter = set.iterator();
// while(iter.hasNext()){
// //取出并移除元素
// String s = iter.next();
// System.out.println(s);
// }
// 取出元素，使用增强for循环
for (String s : set) {
System.out.println(s);
}
}
对于set集合 取出集合中的元素 有两种方法
方法一 通过获得迭代器的方法
Set接口中 public Iterator<E> iterator() 函数
返回对此 set 中元素进行迭代的迭代器。返回元素的顺序并不是特定的
再通过 Iterator类中的 E next() 返回迭代的下一个元素
Iterator<String> iter = set.iterator();
while(iter.hasNext()){
//取出并移除元素
String s = iter.next();
System.out.println(s);
}
注：1 迭代器中 每取出一个元素 都会将元素移除迭代器 但对Set集合没哟影响
2 Iterator类中hasNext(）函数 如果仍有元素可以迭代，则返回 true
方法二 ： 用使用增强for循环来取出元素
for (String s : set) {
System.out.println(s);
}
TreeSet：
public static void treeSetDemo(){
//创建TreeSet对象
TreeSet<Integer> set = new TreeSet<Integer>();
set.add(100);
set.add(80);
set.add(110);
set.add(120);
set.add(119);
set.add(1);
Integer tt = new Integer(111);
set.add(tt);
Integer tt1 = new Integer(111);
set.add(tt1);
// 返回此 set 中所包含元素的逆序视图
NavigableSet<Integer> nset = set.descendingSet();
for(int t:nset){
System.out.println(t);
}
//获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
// while(!set.isEmpty()){
// int t = set.pollLast();
// System.out.println(t);
// }
}
接口 Map<K,V> 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
键：是一个set，不重复，无下标 无序
值：每个键对应一个值，可重复
一个键只能对应一个值
一个值只能指向一个键
public static void main(String[] args) {
//映射存储学号和姓名
HashMap<Integer,String> map = new HashMap<Integer,String>();
//放入数据
map.put(123, "张三疯");
map.put(124, "郭靖");
map.put(125, "张无忌");
map.put(126, "张翠山");
//如果key重复，则会替换key对应的value
map.put(126, "苗翠花");
map.put(126, "翠花");
/*
//取出数据：根基EntrySet
Set<Map.Entry<Integer, String>> set = map.entrySet();
//Map.Entry：一个键值对就是一个Entry对象
for(Map.Entry<Integer, String> entry:set){
int key = entry.getKey();
String value = entry.getValue();
System.out.println(key+">>>"+value);
}
*/
//遍历方式二：根据KeySet
Set<Integer> set = map.keySet();
for(int key:set){
String value = map.get(key);
System.out.println(key+">>>"+value);
}
}
注：
1 HashMap中 如果key重复，则会替换key对应的value
2 Map取元素 有两种方法
方法一：
通过Map中Set<Map.Entry<K,V>> entrySet()方法 返回此映射中包含的映射关系的 Set 视图 再通过Set得到Map.Entry对象 K getKey() 返回与此项对应的键。 V getValue() 返回与此项对应的值。
方法二：
根据KeySet 返回此映射中包含的键的 Set 视图
再通过 V get(Object key) 返回指定键所映射的值
练习:给定任意字符串，统计该字符串中每个字符出现的次数
String s="abbcccddddeeeee";
public static void main(String[] args) {
// TODO Auto-generated method stub
String str = "abbcccddddeeeee";
TreeMap<Character,Integer> map = new TreeMap<Character,Integer>();
for(int i=0;i<str.length();i++){
if(map.containsKey(str.charAt(i))){
int b = map.get(str.charAt(i));
map.put(str.charAt(i), ++b);
}else{
map.put(str.charAt(i), 1);
}
}
//通过entrySet得到映射关系映射关系
// Set<Entry<Character, Integer>> set=map.entrySet();
// for(Entry<Character, Integer> q:set){
// System.out.println(q.getKey()+" "+q.getValue());
// }
//通过keySet包含的键的 Set 再通过键 得到 键所对应值
Set<Character> t = map.keySet();
for(char b:t){
System.out.println(b+" "+map.get(b));
}
//迭代器循环取出元素
// Iterator ter = tree.iterator();
//
// while(ter.hasNext()){
// System.out.println(ter.next());
// }
}