内置模板

内置模板

1. Vector 容器（类）,主要作用就是可变长度的数组，就把他当成数组使用

//第一种构造方法创建一个默认的向量，默认大小为 10：
Vector()
//第二种构造方法创建指定大小的向量。
Vector(int size)
//第三种构造方法创建指定大小的向量，并且增量用 incr 指定。增量表示向量每次增加的元素数目。
Vector(int size,int incr)
//第四种构造方法创建一个包含集合 c 元素的向量：
Vector(Collection c)

1. boolean add(E e)将指定的元素附加到此 Vector 的末尾。

2. void add(int index, E element)在此 Vector 的指定位置插入指定元素。

3. boolean addAll(Collection<? extends E> c)将指定集合中的所有元素追加到末尾 这个向量，按照它们由指定的返回的顺序 集合的迭代器。

4. boolean addAll(int index, Collection<? extends E> c)将指定 Collection 中的所有元素插入到此 指定位置的向量。

5. void addElement(E obj)将指定的组件添加到此向量的末尾， 将其大小增加一。

6. int capacity()返回此向量的当前容量。

7. void clear()从此 Vector 中删除所有元素。

8. boolean contains(Object o) 此向量包含指定的元素。

9. E get(int index)返回此 Vector 中指定位置的元素。

10. boolean isEmpty()测试此向量是否没有组件。

11. Iterator iterator()以适当的顺序返回此列表中元素的迭代器

12. E remove(int index)移除此 Vector 中指定位置的元素。

13. E set(int index, E element)将此 Vector 中指定位置的元素替换为指定的元素。

    每种容器类型都定义了自己的迭代器类型 vector：vector< int>:: iterator iter;//定义一个名为iter的变量数据类型是由 vector< int> 定义的 iterator 类型。简单说就是容器类定义了自己的 iterator 类型，用于访问容器内的元素。每个容器定义了一种名为 iterator 的类型，这种类型支持迭代器的各种行为。

例题：

快递员需要对快递进行分拣，现在小李是一名快递员，他想要你帮他设计一个程序用于快递的分拣，按城市分开。

现在有以下输入：

单号 省份

请你将单号按照城市分开，并输出。 城市按照输入顺序排序 单号按照输入顺序排序

样例如下：

输入

10 

10124214 北京
12421565  上海
sdafasdg213 天津
fasdfga124 北京
145252  上海
235wtdfsg 济南
3242356fgdfsg 成都
23423 武汉  
23423565f 沈阳
1245dfwfs 成都

输出

北京 2
10124214
fasdfga124
上海 2
12421565
145252
天津 1
sdafasdg213
济南 1
235wtdfsg
成都 2
3242356fgdfsg 
1245dfwfs 
武汉 1
23423
沈阳 1
23423565f 

分析思路：

首先我们要知道中国城市肯定在 1000 个以内，但是单号我们不确定，我们不可能每个数组开 10000 个，那样内存不够，所以这时候 就用到了 vector，他的容量是动态申请的，我们可以理解为无限制。

1. 第一步：我们创建一个 vector 用于保存地址

2. 第二步：我们创建一个 vector 组用于存放单号

3. 定义一个映射函数，因为你的城市可能会再次出现，你需要知道之前有没有。

4. 开始读入操作并按照顺序进行存放

   代码实现：

   package Vector练习;
   
   import java.util.Scanner;
   import java.util.Vector;
   
   public class FenKuaiDi {
   	//保存城市
   	static Vector<String> city=new Vector<String>();
   	//存放各个单号，注意每个单号又是一个Vector数组
   	static Vector <Vector<String>>  number = new Vector <Vector<String>>();
   	//定义一个映射函数，判断城市之前是否已经出现。 直接遍历存放城市的集合就可。
   	static int find(String stringCity) {
   		for(int i=0;i<city.size();i++) {
   			if(city.get(i).equals(stringCity)) {
   				return i;
   			}
   		}
   		return -1;
   	}
   	
   	public static void main(String[] args) {
   		
   		Scanner  scanner = new Scanner(System.in);
   		//所有的单号总和
   		int n = scanner.nextInt();
   		//输入每组 单号 城市 同时要判断此城市此前是否已经出现过，注意添加的位置
   		for(int i=0;i<n;i++) {
   			String dString = scanner.next();//单号
   			String cString = scanner.next();//城市
   			//判断此城市此前是否已经出现过
   			int flag = find(cString);
   			if(flag == -1) {//之前这个城市未保存在city集合中
   				city.addElement(cString);
   				number.addElement(new Vector<String >());//特别注意，此处的Vector的嵌套
   				number.get(city.size()-1).addElement(dString);
   			}
   			else {//之前这个城市已经保存在city集合中
   				number.get(flag).addElement(dString);//精妙之处：number.get(flag) 对应于city 中重复出现的城市，但由于编号不同 也要保存单号，这样还可以使编号与城市的下标对应起来 一个城市可能对应许多单号
   			}
   		}
   		//输出：
   		for(int i=0;i<city.size();i++) {
   			System.out.println(city.get(i)+" "+number.get(i).size());
   			for(int j=0;j<number.get(i).size();j++) {
   				System.out.println(number.get(i).get(j));
   			}
   		}
   		
   	}
   }
   

   2. Java 中的队列和栈（直接调用已经存在的数据结构，不用再用数组模拟）

   定义方式：

   Queue<String> queue = new LinkedList<String>();
   Stack mystack = new Stack ();
   

   3. Map 映射

   Map 是一个关联容器，它提供一对一的 hash。

   1. Map接口 (以key和value的这种键值对存储元素)，key和value都是存储java对象的内存地址，所有Map集合的key都是无序不可重复的
      V put(K key, V value) 向 Map中添加键值对
      V get( Object key ) 通过key获取value
      void clear() 清空Map集合
      boolean containsKey( Object key ) 判断Map中是否包含某个key
      boolean containsValue( Object value ) 判断Map中是否包含某个 value
      V remove( Object key ) 通过key删除键值对
      int size() 获取键值对的数量
      Collection<V> values() 获取Map集合中的所有的value ,返回一个Collection集合
      boolean isEmpty( ) 判断Map集合中元素的个数是否为0

   例题：

   有大量的单词需要处理，现在 写一款程序，判断是否出现重复的两个单词。
   

   有重复就输出重复单词，重复就输出 NO，多个重复输出最先出现的哪一个。

   输入：

   
   第 1 行，输入N，代表共计创造了多少个单词
   第 2 行至第 N+1 行，输入 N 个单词
   
   格式：  
   
       fjsdfgdfsg
       fdfsgsdfg
       bcvxbxfyres 
   

   样例输入：

   
   输入：
   
   5
   sdfggfds
   fgsdhsdf
   dsfhsdhr
   sdfhdfh
   sdfggfds
   
   输出：
   sdfggfds
   

   代码实现：

   import java.util.Map;
   import java.util.Scanner;
   import java.util.TreeMap;
   
   public class Test {
   
   	static Map map = new TreeMap();
   	
   	public static void main(String[] args) {
   		 
   		 Scanner scanner = new Scanner(System.in);
   		 int n = scanner.nextInt();//单词总数
   		 boolean flag = false;//标记单词是否出现过
   		 String result = "NO";
   		 //输入各个英语单词
   		 for(int i=0;i<n;i++) {
   			 String word = scanner.next();
   			 if(flag) {
   				 continue;
   			 }
   			 if(map.containsKey(word)) {//此单词已经保存在Map集合的key部分
   				 flag = true;
   				 result = word;
   			 }
   			 else {
   				 map.put(word,true);
   				 //此单词没有保存在Map集合的key部分，则直接保存进Map集合的key部分，对应的value就保存true;
   			 }
   		 }
   		 System.out.println(result);
   	}
   
   }