一、需求：读取txt文件内容按成绩排序后输出
二、分析步骤：

创建txt学生信息文件
创建学生类
创建字符缓冲输入流对象
创建ArrayList集合
调用缓冲输入流对象的方法读取数据
把读取到的字符串数据读取到集合中
释放资源
遍历集合

创建txt文件:  由于姓名与成绩之间用 英文逗号,隔开，下边会用split()来匹配 , 拆分字符串
姓名 成绩
张三,50
李四,20
王五,100
赵六,60

创建学生类
package collection;

public class Student {
	private String name;
	private int grade;

	

	public Student(String name, int grade) {
		super();
		this.name = name;
		this.grade = grade;
	}

	

	public Student() {
		super();
	}



	public String getName() {
		return name;
	}



	public void setName(String name) {
		this.name = name;
	}



	public int getGrade() {
		return grade;
	}



	public void setGrade(int grade) {
		this.grade = grade;
	}



	@Override
	public String toString() {
		return "Student [name=" + name + ", grade=" + grade + "]";
	}

}



创建测试类FileToArrayListDemo
package collection;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

//读取文件并按成绩排序
public class FileToArrayListDemo {

	/**
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		// 设置防止乱码格式
		InputStreamReader isr = new InputStreamReader(new FileInputStream(
				"E:/dc.txt"), "utf8");
		// 读取文件
		BufferedReader br = new BufferedReader(isr);
		// 创建集合
		ArrayList<Student> ar = new ArrayList<Student>();
		String line;
		// 标题行
		String title = null;
		int in = 0;
		Student student = null;
		while ((line = br.readLine()) != null) {
			// 每次循环创建新的学生对象
			student = new Student();
			// 获取标题行
			if (in == 0) {
				title = line;
				System.out.println(title);
				in = 1;
			} else {
				// 切割字符串
				String[] strAy = line.split(",");
				// 设置属性
				student.setName(strAy[0]);
				student.setGrade(Integer.parseInt(strAy[1]));
				ar.add(student);
			}

		}

		br.close();

		for (Student s : ar) {

			System.out.println(s.getName() + "," + s.getGrade());
		}
		// 集合排序使用匿名内部类Collections
		Collections.sort(ar, new Comparator<Student>() {

			@Override
			public int compare(Student s1, Student s2) {
				// TODO Auto-generated method stub
				// 排序主要条件：按成绩排序
				int num = s1.getGrade() - s2.getGrade();
				return num;
			}

		});

		for (Student s : ar) {
			System.out.println(s.getName() + "," + s.getGrade());
		}
		// 写进指定文件
		BufferedWriter bw = new BufferedWriter(new FileWriter("E:/dcg.txt"));
		// 写入标题行
		bw.write(title + "\n");
		for (Student s : ar) {
			bw.write(s.getName() + "   " + s.getGrade());
			bw.newLine();

		}
		bw.close();
	}

}


最后输入文件内容为
姓名   成绩
李四   20
张三   50
赵六   60
王五   100

重要的步骤全写注释了，加油！！

如果要对数据库表中一列或多列的值进行排序，使用索引可快速访问数据库表中的特定信息。例如想按特定职员的姓来查找他或她，则与在表中搜索所有的行相比，索引有助于更快地获取信息。如果没有索引，必须遍历整个表，就会很麻烦。在python中，也有对列表做索引的函数，就是index() 函数，具体怎么使用呢，下面来介绍下。
1、index() 函数
用于从列表中找出某个值第一个匹配项的索引位置。
2、index()方法语法
list.index(x[, start[, end]])
3、参数
x-- 查找的对象。
start-- 可选，查找的起始位置。
end-- 可选，查找的结束位置。
4、返回值
该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。
5、实例
代码：
str1 = "this is string example....wow!!!"

str2 = "exam"

  

print(str1.index(str2))
以上就是关于index() 函数的内容了，现在你对index() 函数有了解了吗，希望能对你有所帮助哦~

                    
一、顺序查找
顺序查找对序列本身没有要求（比如不需要是已经排序好的），也不仅限于数字、字符，也可以用于前缀，对象信息的关键信息的匹配（比如查找指定id的相应信息）。
衡量查找性能的一个指标是————ASL(Average Search Length)，ASL=Pi乘Ci，Pi是查找第i个元素的概率，Ci是找到第i个已经比较过次数。
哨兵方式的顺序查找相比较基础的顺序查找在循环的比较部分减少了一般。
//1. 顺序查找
public class SequentialSearch {
    private int[] array;
    
    public SequentialSearch(int[] array) {
        this.array = array;
    }
    
    public int search(int key) {
        for(int i = 0; i < array.length; i++) {
            if(array[i] == key) {
                return i;
            }
        }
        return -1;
    }
}

//2. 哨兵方式顺序查找
public class Search2 {
    private int[] array;
    
    public Search2(int[] array) {
        this.array = array;
    }
    
    public int search(int key) {
        if(key == array[0]) {
            return 0;
        }
        int temp = array[0];
        array[0] = key;
        int index = array.length-1;
        while(array[index] != key) {
            index--;
        }
        array[0] = temp;
        if(index == 0) {
            return -1;
        }else {
            return index;
        }
    }
}

二、二分查找
如果是顺序查找，7个数最多可能会比较7次，但用二分查找，最多只要3次就能OK。时间复杂度是O（logn）(底数为2)。
二分查找的优化————插值查找
如果数据范围是1~100000,让你找10,那么就不一定要从中间找起了。可以三分之一，四分之一处查找，比如1~10，待查为3，那可以从前面三分之一为划分点。对于要查找的位置有个精确的计算公式P=low+（key-a[low])/(a[high]-a[low])*(high-low)
//1. 二分查找递归与非递归的实现
public class BinarySearch {
    private int[] array;
    
    public BinarySearch(int[] array) {
        this.array = array;
    }
    
    public int searchRecursion(int target) {
        if(array == null) {
            return -1;
        }
        return  searchRecursion(target, 0, array.length - 1);
    }
    
    public int search(int target) {
        if(array == null) {
            return -1;
        }
        int start = 0;
        int end = array.length - 1;
        while(start <= end) {
            int mid = start + (end - start) / 2;
            if(array[mid] == target) {
                return mid;
            }else if(target < array[mid]) {
                end = mid - 1;
            }else {
                start = mid + 1;
            }
        }
        return -1;
    }
    
    private int searchRecursion(int target, int start, int end) {
        if(start > end) {
            return -1;
        }
        int mid = start + (end - start) / 2;
        if(array[mid] == target) {
            return mid;
        }else if(array[mid] < target) {
            return searchRecursion(target, mid + 1, end);
        }else {
            return searchRecursion(target, start, mid -1);
        }
    }
}

//2. 二分插入排序
public class BinaryInsertSort {
    private int[] array;
    
    public BinaryInsertSort(int[] array) {
        this.array = array;
    }
    
    public void sort() {
        int length = array.length;
        for(int i = 1; i < length; i++) {
            int temp = array[i];
            int insertIndex = binarySearch(i - 1, temp);
            if(insertIndex != i) {
                for(int j = i; j > insertIndex; j--) {
                    array[j] = array[j - 1];
                }
                array[insertIndex] = temp;
            }
        }
    }
    public void print() {
        for(int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
    private int binarySearch(int end, int target) {
        int start = 0;
        int mid = -1;
        while(start <= end) {
            mid = start + (end - start) / 2;
            if(array[mid] > target) {
                end = mid - 1;
            }else {
                //如果相等，也插入到后面
                start = mid + 1;
            }
        }
        return start;
    }
}
三、杨氏矩阵的的查找
杨氏矩阵就是行列递增的矩阵。
杨氏矩阵的操作
插入。插入一个数，需要移动其他元素
删除。给定x,y坐标，删除那个数，伴随其他元素移动，怎样移动操作最少？

查找t是否存在于矩阵中。这也是这篇博客里所要关注的。
返回第k大的数。涉及到堆查找，后续博客再细说。
关于查找t是否存在于矩阵，书中给了几种实现的方法：
递归实现和非递归实现
优化：
每次不都从每行的第一个数开始查找，左右上下进行比较然后查找。
分治法。杨氏矩阵行列是递增的，那么对角线也是递增的，可以利用对角线划分的区域来缩小要查找数的范围。（实现略）
定位查找法。先定位到第一行最右的数，然后只需要往下走，往左走两种操作即可，相比方法2省掉了往右走。
public class YoungSearch {
    private int[][] array;
    
    public YoungSearch(int[][] array) {
        this.array = array;
    }
    //1.递归实现
    public boolean recursionSearch(int x, int y, int target) {
        if(x == array.length || y == array[0].length) {
            return false;
        }
        if(target < array[x][y]) {
            return false;
        }
        if(target == array[x][y]) {
            System.out.println(String.format("x: %d, y: %d", x, y));
            return true;
        }
        return recursionSearch(x + 1, y, target) || recursionSearch(x, y + 1, target);
    }
    //非递归实现
    public boolean search(int target) {
        for(int i = 0; i < array.length; i++) {
            for(int j = 0; j < array[0].length && target >= array[i][j]; j++) {
                if(target == array[i][j]) {
                    System.out.println(String.format("x: %d y: %d", i, j));
                    return true;
                }
            }
        }
        return false;
    }
    //2.简单优化（向左/右/下走）
    public boolean search2(int target) {
        int width = array[0].length;
        int height = array.length;
        if(target >= array[0][0]) {
        int i = 0;
        for(; i < width && target >= array[0][i]; i++) {
            if(target == array[0][i]) {
                System.out.println(String.format("x: %d, y: %d", 0, i));
                return true;
            }
        }
        if(i > width - 1) {
            i--;
        }
        //循环向下查找
        for(int j = 1; j < height; j++) {
            if(target == array[j][i]) {
                System.out.println(String.format("x: %d, y: %d", j, i));
                return true;        
            }else if(target < array[j][i]) {
                for(; i >= 0; i--) {
                    if(target == array[j][i]) {
                        System.out.println(String.format("x: %d, y: %d", j, i));
                        return true;
                    }else if(target > array[j][i]) {
                        break;
                    }
                }
                if(i < 0) {
                    i++;
                }
            }else if(target > array[j][i]) {
                for(; i < width; i++) {
                    if(target == array[j][i]){
                        System.out.println(String.format("x: %d, y: %d", j, i));
                        return true; 
                    }else if(target < array[j][i]) {
                        break;
                    }
                }
                if(i > width - 1) {
                    i--;
                }
            }
        }
        }
        return false;
    }
    //3.进一步优化（从第一行最右边的数开始，只需要向下和向左两个操作）
    public boolean search3(int target) {
        int i = 0;
        int j = array[0].length - 1;
        int temp = array[i][j];
        while(true) {
            if(target == temp) {
                System.out.println(String.format("x: %d, y: %d", i, j));
                return true;
            }else if(j > 0 && target < temp){
                temp = array[i][--j];
            }else if(i < array.length - 1 && target > temp) {
                temp = array[++i][j];
            }else {
                return false;
            }
        }
    }
}
四、分块查找
对于待查找的数据列表来说，如果元素变动很少，那么可以先进行排序再查找。但如果这个数据经常需要添加元素，那么每次查找前都需要排序，这并不是一个好的选择。
就有了分块查找，这个概念再学数据库的时候听过。分块查找里有索引表和分块这两个概念。索引表就是帮助分块查找的一个分块依据，就是一个数组，用来存储每块最大的存储值（范围上限）；分块就是通过索引表把数据分为几块。
原理：当需要增加一个元素的时候，先根据索引表，获取这个元素应该在那一块，然后直接把元素加入到相应的块里，而块内的元素直接不需要有序。
从上面可知，分块查找只需要索引表有序，每一个块里的元素可以是无序的，但第i块的每个元素一定比第i-1块的每一个元素大（小）。当索引表很大的时候，可以对索引表进行二分查找，锁定块的位置，然后对块内的元素进行顺序查找。总性能不如二分查找，但强过顺序查找，更好的是不需要数列完全有序。
举个例子，比如索引表为【10，20，30】,分块一【2，1，4，2】分块二【19，15，18，】分块三【22，27，23】，现在要增加22这个数，直接根据索引表把22放到分块三最后就行了【22,27,23,22】。
可以看出，分块查找同时有顺序查找和二分查找的有点————不需要有序、速度快。
应用场景
视频网站对用户观看行为记录，每个用户分别观看了一个视频多久，如果对每条这样的记录都放到一个表里，那太多了，可以根据具体业务做分表，一天一个表，表名如t_user_watch_xxx_20180806，存储查询的时候就可以根据时间去做一个表的分块，在查询详细的记录。
//分块查找
import java.util.ArrayList;

public class BlockSearch {
    private int[] index;
    private ArrayList<ArrayList<Integer>> list;
    
    public BlockSearch(int[] index) {
        this.index = index;
        list = new ArrayList<ArrayList<Integer>>();
        for(int i = 0; i < index.length; i++) {
            list.add(new ArrayList<Integer>());
        }
    }
    
    public void insert(Integer value) {
        int i = binarySearch(value);
        list.get(i).add(value);
        
    }
    
    public boolean search(int data) {
        int i = binarySearch(data);
        for(int j = 0; j < list.get(i).size(); j++) {
            if(data == list.get(i).get(j)) {
                return true;
            }
        }
        return false;
    }
    public void printAll() {
        for(int i = 0; i < list.size(); i++) {
            ArrayList<Integer> l = list.get(i);
            System.out.println("ArrayList: " + i +  ":");
            for(int j = 0; j < l.size(); j++) {
                System.out.println(l.get(j));
            }
        }
    }
    
    private int binarySearch(int target) {
        int start = 0;
        int end = index.length - 1 ;
        int mid = -1;
        while(start <= end) {
            mid = (start + end) / 2;
            if(target == index[mid]) {
                return mid;
            }else if(target < index[mid]) {
                end = mid - 1;
            }else {
                start = mid + 1;
            }
        }
        return start;
    }
}


        
        
                
    

JAVA 8 新特性
一、Lambda 表达式
Consumer
Predicate
Function
Supplier
二、stream 流
1. 获取流
2. 中间操作
1.1）map 把对应的操作应用到 流里面的每一个对象上
1.2）map 提取对象里面的信息
2)filter 过滤
3)skip()
4)distinct() 去重
5)sorted(),默认是自然排序，可以定义排序规则
3. 终止操作
1）分组，根据条件，把流中的数据，拆分成不同的组
2）分区
3） count（）
4）收集
5）reduce
4）max
5）min
全部匹配   allMatch
至少一个匹配  anyMatch
没有匹配的元素，返回true，否则false    noneMatch
三、ForkJoin
工作窃取模式
原理
示例 累加器 加到10亿
第一个模块，拆分工作的算法
第二个模块，使用
并行流。实现累加
四、Optional
五、新的时间API

一、Lambda 表达式
四个内置的接口

函数式接口  只有一个方法的接口
Consumer
属于函数式接口，只有一个accept 方法

接收一个参数无返回值


Predicate
接收一个泛型，返回 boolean


Function
接收两个，一个是入参，一个是返回值


Supplier
传入一个参数，返回一个对象


二、stream 流
1. 获取流
1）集合类  xxx.stream()
2）Arrays

Object[] objects={1,2,3,4,5,6};

Stream stream = Arrays.stream(objects);
2. 中间操作
1.1）map 把对应的操作应用到 流里面的每一个对象上
/*
给定一个数字列表，返回平方列表
 */

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> collectList = integerList.stream()
        .map(x -> x = x * x)
        .collect(Collectors.toList());

System.out.println(collectList);

1.2）map 提取对象里面的信息
示例

数据

Trader raoul = new Trader("Raoul", "Cambridge");
Trader mario = new Trader("Mario", "Milan");
Trader alan = new Trader("Alan", "Cambridge");
Trader brian = new Trader("Brian", "Cambridge");

List<Transaction> transactionList = Arrays.asList(
        new Transaction(brian, 2011, 300),
        new Transaction(raoul, 2012, 1000),
        new Transaction(raoul, 2011, 400),
        new Transaction(mario, 2012, 710),
        new Transaction(mario, 2012, 700),
        new Transaction(alan, 2012, 950)
);

测试示例
@Test
public void test08() {
    //提取所有交易员的名字,去除重复
    transactionList.stream()
            .map(Transaction::getTrader)
            .map(Trader::getName)
            .distinct()
            .forEach(System.out::println);
}

解析

第一次  stream 之后，流里面是一个个的Transaction 对象，map 之后，流里面是一个个的Trader对象，再次map之后，是一个个的String  ，可能有重复的，所以使用 去重

最终得到所有的交易员的姓名
2)filter 过滤
示例 过滤，只留下 大于 3  的数字
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);

integerList.stream()
        .filter(x->x>3)
        .forEach(System.out::println);

3)skip()
跳过前面的几个
4)distinct() 去重
5)sorted(),默认是自然排序，可以定义排序规则
3. 终止操作
1）分组，根据条件，把流中的数据，拆分成不同的组
数据如下
List<Employee> employeeList = Arrays.asList(
        new Employee(101, "张三", 10, "1111.0", Status.FREE),
        new Employee(102, "李四", 20, "2222.0", Status.FREE),
        new Employee(104, "田七", 30, "4444.0", Status.VOCATION),
        new Employee(103, "王五", 30, "3333.0", Status.FREE),
        new Employee(105, "天珩", 50, "5555.0", Status.FREE),
        new Employee(106, "珩媛", 60, "6666.0", Status.VOCATION),
        new Employee(105, "天珩", 40, "9999.0", Status.BUSY),
        new Employee(105, "天珩", 40, "7777.0", Status.BUSY)

);

测试代码
逻辑：根据年龄把员工分三个组 青年，中年，老年
@Test
public void test08() {

    //分组
    ConcurrentMap<Status, Map<String, List<Employee>>> groups = employeeList.stream()
            .collect(Collectors.groupingByConcurrent(Employee::getStatus, Collectors.groupingBy(employee -> {
                if (employee.getAge() <= 35) {
                    return "青年";
                } else if (employee.getAge() <= 50) {
                    return "中年";
                } else {
                    return "老年";
                }

            })));

    groups.forEach((key,value)->{

        System.out.println("key is "+key+"\nvalue is "+value);
    });
}

输出的结果
2）分区
可以分true  false 两个区
@Test
public void test09() {
    //分区
    Map<Boolean, List<Employee>> partitioningByAge = employeeList.stream()
            .collect(Collectors.partitioningBy(employee -> employee.getAge() > 35));
    partitioningByAge.forEach((key,value)-> System.out.println("key is "+key+"\nvalue is "+value));


}

3） count（）
返回一个 Long 类型数据，流的对象个数
4）收集
ArrayList collect1 = employeeList.stream()            .collect(Collectors.toCollection(ArrayList::new));
5）reduce
4）max
5）min
全部匹配   allMatch
至少一个匹配  anyMatch
没有匹配的元素，返回true，否则false    noneMatch

三、ForkJoin
工作窃取模式
原理
会划分多个工作线程，每个线程独立的并行工作，当某线程已经完成，还有别的线程没有完成时，会取得其余线程的末尾工作，继续执行，这样中分的利用 CPU 的每个核的资源
传统的线程会等待最慢的线程执行完成之后，整个工作才结束，ForkJoin会利用工作窃取，分担最慢的工作。
示例 累加器 加到10亿
第一个模块，拆分工作的算法
继承 RecursiveTask  实现compute（）方法，有返回值

继承 RecursiveAction实现compute（）方法，无返回值
public class ForkJoinCal extends RecursiveTask<Long> {
    /**
     * RecursiveAction
     * protected abstract void compute(); 没有返回值
     *
     */

    private Long start;
    private Long end;
    private static final Long THRESODLD=10000L;

    public ForkJoinCal(Long start, Long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        Long length=end-start;

        if (length<=THRESODLD){
            Long sum=0L;

            for (Long i=start;i<=end;i++){
                sum+=i;
            }
            return sum;
        }else {
            Long middle = (start + end) / 2;
            ForkJoinCal left=new ForkJoinCal(start ,middle);
            //拆分子任务，压入栈
            left.fork();
            ForkJoinCal right = new ForkJoinCal(middle + 1, end);
            //拆分子任务，压入栈
            right.fork();

            return left.join()+right.join();

        }

    }

}

第二个模块，使用
@Test
public void test01(){

    Instant start=Instant.now();
    ForkJoinPool forkJoinPool = new ForkJoinPool();
    ForkJoinTask<Long> forkJoinTask=new ForkJoinCal(0L,1000000000L);
    Long sum = forkJoinPool.invoke(forkJoinTask);

    System.out.println("this is sum : "+sum);
    }

运行时，可以查看 CPU 状态，可以看到 利用率非常高
并行流。实现累加
//并行流
Long reduceSum = LongStream.range(0, 100000001L)
        //并行流
        .parallel()
        .reduce(0, Long::sum);
底层使用的也是 fork join 机制，效率更高

四、Optional
提供了新的接口，确保快速定位到null

empty()  创建一个空对象，对象不是null 只是对象的属性都是null
of()创建一个可以为null 的对象
ofNullable（）创建对象，调用的是empty()和 of()
isPresent()判断对象是否为null  ，null 返回false orElse（T t）如果对象为null，则创建一个默认的对象  t
orElseGet 可以 自己定义构造一个默认的对象

五、新的时间API
Instant

LocalDateTime

Duration

Period