【FFmpeg学习】视频变慢处理

一、Collection 

1.1 Java List

以下情况使用 ArrayList :

• 频繁访问列表中的某一个元素。
• 只需要在列表末尾进行添加和删除元素操作。

以下情况使用 LinkedList :

• 你需要通过循环迭代来访问列表中的某些元素。
• 需要频繁的在列表开头、中间、末尾等位置进行添加和删除元素操作。

1.1.1 ArrayList

import java.util.*;

public class RunoobTest {
    public static void main(String[] args) {
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob"); //1、添加：元素到sites对象中
        sites.set(0,"Yahu"); //2、第一个参数为索引位置，第二个为要修改的值、
        sites.remove(1);     //3、删除第2个元素
        System.out.println(sites.size());         //4、输出对象长度
        for (int i = 0; i < sites.size(); i++) {  //5、for循环迭代输出
            System.out.println(sites.get(i));
        }
        for (String i : sites) {    //6、for-each循环迭代输出
            System.out.println(i);
        }
        ArrayList<Integer> li=new ArrayList<>();  //7、存放整数元素
        Collections.sort(sites);  //8、Collections类中sort() 方法可以对字符或数字列表进行排序排序
        System.out.println(sites);
    }
}

常规方法：

实例：

import java.util.*;
//遍历ArrayList
public class Test{
 public static void main(String[] args) {
     List<String> list=new ArrayList<String>();
     list.add("Hello");
     list.add("World");
     list.add("HA");

     //第一种遍历：使用 For-Each 遍历 List
     for (String str : list) {    //也可以改写for(int i=0;i<list.size();i++) 这种形式
        System.out.println(str);
     }
 
     //第二种遍历：把链表变为数组相关的内容进行遍历
     String[] strArray=new String[list.size()];
     list.toArray(strArray);
     for(int i=0;i<strArray.length;i++) //这里也可以改写为  for(String str:strArray) 这种形式
     {
        System.out.println(strArray[i]);
     }
     
    //第三种遍历：使用迭代器进行相关遍历
     Iterator<String> ite=list.iterator();
     while(ite.hasNext())//判断下一个元素之后有值
     {
         System.out.println(ite.next());
     }
 }
}
//[Hello,World,HA]

1.1.2 LinkedList

// 引入 LinkedList 类
import java.util.LinkedList;

public class RunoobTest {
    public static void main(String[] args) {
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");//1、添加元素
        sites.add("Runoob");
        //2、使用 addFirst() 在头部添加元素
        sites.addFirst("BaiDu");
        //3、尾部添加
        sites.addLast("Wiki");
        //4、使用 removeFirst() 移除头部元素
        sites.removeFirst();
        //5、使用 removeLast() 移除尾部元素
        sites.removeLast();
        //6、使用 getFirst() 获取头部元素
        System.out.println(sites.getFirst());
        //7、使用 getLast() 获取尾部元素
        System.out.println(sites.getLast());
        //9、迭代获取元素
        for (int size = sites.size(), i = 0; i < size; i++) {
            System.out.println(sites.get(i));
        }
        //10、for-each 迭代
        for (String i : sites) {
            System.out.println(i);
        }
        //11、foreach遍历方式 
        sites.forEach(ites->{
        System.out.println(ites);
    });
        System.out.println(sites);
    }
}

使用较少，类比ArrayList，不举例。

1.1.3 Vector

Vector是一种老的动态数组，是线程同步的，效率很低，一般不使用。

1.2 Java Set

1.2.1 HashSet

// 引入 HashSet 类      
import java.util.HashSet;

public class RunoobTest {
    public static void main(String[] args) {
    HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");  //1、重复的元素不会被添加
        System.out.println(sites.contains("Taobao"));//2、判断元素是否存在于集合当中
        sites.remove("Taobao"); //3、删除元素，删除成功返回 true，否则为 false
        sites.clear();//4、清除全部               
        for (String i : sites) { //5、for-each 迭代
            System.out.println(i);
        }
       /*6、注意：Set无序，无法使用元素下标输出元素遍历集合
       for (int size = sites.size(), i = 0; i < size; i++)*/
       //7、foreach遍历方式 
       sites.forEach(ites->{
         System.out.println(ites);
    });
        System.out.println(sites);
    }
}

1.2.2 LinkedHashSet 

底层数据结构采用链表和哈希表共同实现，链表保证了元素的顺序与存储顺序一致，哈希表保证了元素的唯一性。线程不安全，效率高。

1.2.3 TreeSet 

底层数据结构采用二叉树来实现，元素唯一且已经排好序。

二、Map

2.1 Java Map

2.1.1 HashMap

// 引入 HashMap 类      
import java.util.HashMap;

public class RunoobTest {
    public static void main(String[] args) {
        //1、创建 HashMap 对象 Sites
        HashMap<Integer, String> Sites = new HashMap<Integer, String>();
        Sites.put(1, "Google");
        Sites.put(2, "Runoob");
        Sites.put(3, "Taobao");
        Sites.put(4, "Zhihu");
        System.out.println(Sites);
        //2、输出元素{1=Google, 2=Runoob, 3=Taobao, 4=Zhihu}
        System.out.println(Sites.get(3));//输出Taobao
        for (Integer i : Sites.keySet()) {
            System.out.println("key: " + i + " value: " + Sites.get(i));
        }
          //3、返回所有 value 值
        for(String value: Sites.values()) {
          //4、输出每一个value
          System.out.print(value + ", ");
          //5、使用Entry对象遍历
      Map<String, Integer> map = new HashMap<>();
        map. put("yly", 177);
        map. put("yrc" ,176);
        map. put("zcz" ,175);
        Set<Map.Entry<String, Integer>> set = map.entrySet();
        //for迭代遍历
        for (Map.Entry<String, Integer> entry : set) {
            System.out.println(entry.getKey()+entry.getValue());
        }
    }
        }
    }
}

2.1.2 HashTable（略）

2.1.1 TreeMap（略）

三、迭代器 （Iterator）

//主要是作为循环和遍历
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {
        // 创建集合
        ArrayList<Integer> sites = new ArrayList<Integer>();
        sites.add("1");
        sites.add("2");
        sites.add("3");
        sites.add("4");
        // 获取迭代器
        Iterator<Integer> it = sites.iterator();
        // 输出集合中的第一个元素
        System.out.println(it.next());//1
        // 输出集合中的所有元素
        while(it.hasNext()) {
            System.out.print(it.next());
            }//1 2 3 4 
        for(Integer i:sites){
            System.out.print(i+" ");
            }//1 2 3 4
        while(it.hasNext()) {
            Integer i = it.next();
            if(i < 10) {  
                it.remove();  //删除小于 10 的元素
            }
            System.out.println(sites);//[]
        }
/*注意：Java 迭代器是一种单向遍历机制，即只能从前往后遍历集合中的元素，不能往回遍历。同时，在使用迭代器遍历集合时，不能直接修改集合中的元素，而是需要使用迭代器的 remove() 方法来删除当前元素*/
}

import java.util.ArrayList;
import java.util.Iterator;
 
public class Person(String name) {
    private String name;

    public void setName(String name){
    this.name = name;}
    
    public String getName(){
    return name;}
}
public class test {
    public static void main(String[] args) {
        ArrayList<Person> array = new ArrayList<Person>();
 
        Person p1 = new Person("Y");
        Person p2 = new Person("L");
        Person p3 = new Person("Y");
        Person p4 = new Person("G");
 
        array.add(p1);
        array.add(p2);
        array.add(p3);
        array.add(p4);
 
        Iterator<Person> iterator = array.iterator();
 
        for (Person pp : array){
            System.out.print(pp.getName());//Y L Y G 
        }
        
        array.forEach(obj -> System.out.print(obj.getName()));//Y L Y G 
 
        for(Person p : array){
            p.setName("B");
        }
 
        while(iterator.hasNext()){
            System.out.print(iterator.next().getName()); //B B B B
        }
 
    }
}