javaSE(集合操作队列栈,Map,少量io文件操作)

泛型在集合中的引用
泛型是在JavaSe5.0引入的特征,泛型的本质是参数化类型,接口和方法的定义中
所操纵的数据类型被传入的参数指定

java泛型机制广泛的应用在集合框架中,所有的集合类型都带有泛型参数,这样在创建集合时
可以指定放入集合中元素的类型,java编译器可以据此进行类型检查,这样可以减少代码在运行时出现
错误的可能性

ArrayList类的定义中,<E>中的E为泛型参数,在创建对象是可以将类型作为参数传递,此时
类定义所有的E将被替换成传入的参数
public class ArrayList<E>{
public boolean add(E e){........}
public E get(index a){..........}
}

List<String> list = new ArrayList<String>
list.add("one");
list.add(100);java编译器类型检查错误,此时add方法应该传入的参数为String

集合操作----线性表
List接口是Collection的子接口,用于定义线性表数据结构,可以将List理解为存放对象的数组
只不过其元素个数可以动态的增加或减少.

List接口的两个实现类:ArrayList和LinkedList,分别用动态数组和链表的形式实现了List接口

get和set
List除了继承Collection定义的方法外,还根据其线性表的数据结构定义了一系列的方法
其中最常用的就是基于下标的个体和set方法

E get(int  index)
获取集合总指定下标对应的元素,下标从0开始

E set(int  index,E element)
将给定的元素存入给定的位置,并将原位置的元素返回

插入和删除
List根据下标的操作还支持插入和删除操作
void add(int  index,E element)
将给定的元素插入到指定位置,原位置及后续元素顺序都向后移动

E remove(int index)
删除给定位置的元素

subString()
List和数组之间的相互转换
数组的排序

comparable接口以及comparator接口

队列和栈
队列(Queue):先进先出
栈:先进后出     如果将Deque限制为只能从一段入队和出队,则可以实现"栈"stack的数据结构
队列(Queue)是常用的数据结构,可以将队列看成特殊的线性表.队列限制了对线性表的访问方式
只能从线性表的一端添加(offer)元素,从另一端取出(poll)表
队列所遵循的原则:先进先出(FTFO First input First Output) 高速路上有一个隧道

JDK提供了Queue的接口,同时使用LinkedList实现了该接口.(选择LinkedList的原因在于Queue经常
需要进行添加和删除操作,而LinkedList在这方面效率高)

Queue接口中的主要方法如下:
boolean offer(E e):将一个对象添加至队尾,如果添加成功则返回true,否则false
E poll();从队首删除并返回一个元素.
E peek();返回队首元素(但并不删除)

Queue<String> queue = new LinkedList<String>();
        queue.offer("a");
        queue.offer("b");
        queue.offer("c");
        queue.offer("d");
        System.out.println(queue);//[a, b, c, d]
        
        String a = queue.peek();
        while(queue.size()>0){
            System.out.println(queue.poll());//先进先出
        }
栈:先进后出

Deque  先进后出
Deque是Queue的子接口,定义了所谓"双端队列" 即从队列的两端分别可以入队和出队
LinkedList也实现了这个接口

如果将Deque限制为只能从一段入队和出队,则可以实现"栈"stack的数据结构,对于栈而言
入栈称之为push,出现称之为pop

栈遵循先进后出的原则.

Deque<String> stack = new LinkedList<String>();
        stack.push("A");
        stack.push("B");
        stack.push("C");
        stack.push("D");
        System.out.println(stack);
        
        while(stack.size()>0){
            System.out.println(stack.pop());
        }
        System.out.println(stack);
查询表
Map()接口
Map接口定义的集合(查询包),用于存储所谓的"key-value"映射对,key可以看成是value的索引,
作为key的对象在集合中不可以重复

根据数据结构不同,Map接口的实现类很多,其中常用的有内部为hash表实现的HashMap
和内部为排序二叉树实现的TreeMap.

put()方法
Map接口定义了向map中存放元素的put方法:
V put(K key,V value)
将Key-Value对存入Map,如果在集合中已经包含该Key则操作将替换掉该Key所对应的value值
返回该key原来所对应的值value.(如果没有则返回null)

get()方法:
Map接口中定义了从Map中获取元素的个体方法
V get(Object key)
返回参数key所对应的Value对象,如果不存在则返回null(这里指的是key不存在则返回null)

containsKey()方法
 Map接口中定义了判断某个key是否存在Map中存放
 --boolean containsKey(Object key);
 诺Map中包含给定的key则返回true,否则返回false

如何创建:
Map<String,Integer> map = new HashMap<String,Integer>(); 

练习:检测北京各个站点,某一天中PM2.5的最高的浓度
要求使用Map,并且值记录最高的浓度

    Map<String, Integer> map = new HashMap<String, Integer>();

    public void main02(String str) {

        String[] q = str.split("[=,]");//[0-9]
        //        System.out.println(Arrays.toString(q));
        for (int i = 0; i < q.length; i += 2) {
            if (!map.containsKey(q.length)) {
                if (!map.containsKey(q.length) || Integer.parseInt(q[i + 1]) > map.get(q[i])) {
                    map.put(q[i], Integer.parseInt(q[i + 1]));
                }
            }
        }
        System.out.println(map);
    }

    public static void main(String[] args) {
        String map1 = "通州=208,永乐街=200,昌周=222,地坛=100";
        String map2 = "通州=408,永乐街=100,昌周=222,地坛=100";
        Main02 m = new Main02();
        m.main02(map1);
        m.main02(map2);
    }

有序Map
LinkedHashMap实现有序的Map
使用Map接口的哈希表和链表实现,具有可预知的迭代顺序,此实现与HashMap的不同之处在于
LinkedHashMap维护者一个双循环链表,此链表定义了迭代顺序
该迭代顺序通常就是存储元素的顺序.

遍历map
使用keySet()方法
Map提供了3种遍历方式
遍历所有的key-value对
遍历所有的value(不常用)
        
遍历所有key的方法
Set(K) keySet();        
该方法会将当前Map中所有的key存入有个Set集合后返回.

使用entrySet()方法;
Set<Entry<K,V>> entrySet();
该方法会将当前Map中每一组key-value对封装为一个Entry对象并存入Set集合后返回
Map<Integer,String> map = new HashMap<Integer,String>();
        map.put(0, "1");
        map.put(1, "2");
        map.put(2, "3");
//        String is = map.get(1);
//        map.keySet();
//        Boolean t = map.containsKey(4);
//        System.out.println(t);
        Set<Integer> set = map.keySet();
        for(Integer s:set){
            System.out.println(s+","+map.get(s));
        }
        Set<Entry<Integer, String>>  str = map.entrySet();
        for(Entry<Integer, String> s:str){
            System.out.print(s.getKey()+","+s.getValue()+"  ");
        }
文件操作:
File对象
1.java.io.File用于表示文件(目录),也就是说程序员可以通过File类在程序中操作硬盘上文件和目录.
2.File类只能用于表示文件(目录)的信息(名称,大小等),不能对文件的内容进行访问
3.构造方法
-File(String path/name)
-通过将给定路径名字符字符串转换成抽象路径来创建一个新File实例
-抽象路径名应劲量使用相对路径,并且目录的层级分离符不要直接写"/"或"\"
应使用File.separator这个常量表示,以避免不同系统带来的差异.

练习:查看一个文件的大小
查看当前工程下demo文件下的HelloWorld.txt的文件大小

File(File parent,String child)
File还提供了另一个构造方法.
-根据parent抽象路径和child路径名字符串创建一个新File实例
File f = new File("demo");
File f1 = new File(f,"hello.txt");//demo/hello.txt

isFile()方法
.File的isFile()方法用于判断当前File对象所表示的是否为一个文件
-boolean isFile()
返回值:当前File对象所表示是一个文件是返回true

length()方法
File()length方法用于返回此抽象路径名表示的文件的长度(占用字节量)
-返回值:当前File对象所表示的文件所占用的字节量

exist()方法
File()的exist()方法用于测试此抽象路径名表示的文件或目录是否存在
-Boolean exist()
-返回值:诺该File表示的文件或目录存在则返回true,否则返回false

createNewFile()方法
File的createNewFile方法用于当且仅当不存在具有此抽象路径名指定的名称的文件时,
原子地创建由此抽象路径名指定的一个新的空文件
Boolean createNewFile
-返回值:如果指定的文件不存在并成功的创建,则返回true;如果指定的文件已经存在,则返回false

作业:在当前工程目录下创建一个新的空文件.命名为Test.txt.
要求使用File对象的第二种构造方法

File f = new File("demo");
        File f1 = new File(f,"Test.txt");
        if(!f1.exists()){
            try {
                f1.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }