精华内容
下载资源
问答
  • 一、需求:读取txt文件内容按成绩排序后输出 二、分析步骤: 创建txt学生信息文件 创建学生类 创建字符缓冲输入流对象 创建ArrayList集合 调用缓冲输入流对象的方法读取数据 把读取到的字符串数据读取到集合中 释放...

    一、需求:读取txt文件内容按成绩排序后输出

    二、分析步骤:

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

    创建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
    

    重要的步骤全写注释了,加油!!

    展开全文
  • comparisonImageList.sort(key=lambda x:x[1],reverse=True) #按照匹配排序 count=len(comparisonImageList) column=4 row=math.ceil(count/column) #绘图显示 figure,ax=plt.subplots(row,column) for ...
  • 如果要对数据库表中一列或多列的值进行排序,使用索引可快速访问数据库表中的特定信息。例如想按特定职员的姓来查找他或她,则与在表中搜索所有的行相比,索引有助于更快地获取信息。如果没有索引,必须遍历整个表,...

    7adb38578c548f524a523bdc829f7c84.png

    05bf93c3b1e4e461421418c191408353.png

    如果要对数据库表中一列或多列的值进行排序,使用索引可快速访问数据库表中的特定信息。例如想按特定职员的姓来查找他或她,则与在表中搜索所有的行相比,索引有助于更快地获取信息。如果没有索引,必须遍历整个表,就会很麻烦。在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() 函数有了解了吗,希望能对你有所帮助哦~

    展开全文
  • // 匹配学生学号 System.out.println("所有学生学籍信息如下:"); int cnt = 1; while (cnt ()) { Student s = (Student) Students.get(cnt - 1); ws.addCell(new Label(4, cnt, String.valueOf(s....
  • 1 : 不匹配,参数值来自于语言环境的排序顺序字符串对象的值之前 -1 : 不匹配,参数值来自于语言环境的排序顺序字符串对象的值之后 例子: <html> <head> <title>JavaScript String ...
  • 顺序查找对序列本身没有要求(比如不需要是已经排序好的),也不仅限于数字、字符,也可以用于前缀,对象信息的关键信息的匹配(比如查找指定id的相应信息)。衡量查找性能的一个指标是————ASL(Average Search ...

    一、顺序查找

    顺序查找对序列本身没有要求(比如不需要是已经排序好的),也不仅限于数字、字符,也可以用于前缀,对象信息的关键信息的匹配(比如查找指定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;
        }
    }

    三、杨氏矩阵的的查找

    杨氏矩阵就是行列递增的矩阵。

    杨氏矩阵的操作

    1. 插入。插入一个数,需要移动其他元素
    2. 删除。给定x,y坐标,删除那个数,伴随其他元素移动,怎样移动操作最少?
    3. 查找t是否存在于矩阵中。这也是这篇博客里所要关注的。
    4. 返回第k大的数。涉及到堆查找,后续博客再细说。

    关于查找t是否存在于矩阵,书中给了几种实现的方法:

    1. 递归实现和非递归实现
      优化:
    2. 每次不都从每行的第一个数开始查找,左右上下进行比较然后查找。
    3. 分治法。杨氏矩阵行列是递增的,那么对角线也是递增的,可以利用对角线划分的区域来缩小要查找数的范围。(实现略)
    4. 定位查找法。先定位到第一行最右的数,然后只需要往下走,往左走两种操作即可,相比方法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 新特性

    2020-06-28 11:17:57
    JAVA 8 新特性一、Lambda 表达式ConsumerPredicateFunctionSupplier二、stream 流一、获取流二、中间操作1.1)map 把对应的操作应用到 流里面的每一个对象上1.2)map 提取对象里面的信息2)filter 过滤3)skip()4)...

    一、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

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

    五、新的时间API

    Instant
    LocalDateTime
    Duration
    Period

    展开全文
  • 流式编程流支持流创建随机数流int 类型的范围generate()iterate()流的建造者模式Arrays正则表达式中间操作跟踪和调试流元素排序移除元素应用函数到元素在 `map()` 中组合流Optional类便利函数创建 OptionalOptional ...
  • 谭浩强教授,我国著名计算机教育专家。1934年生。1958年清华大学毕业。学生时代曾担任清华大学学生会主席、北京市人民代表。他是我国计算机普及和高校计算机基础教育开拓者之一,现任全国高等院校...8.4.1 通过对象名...
  • 获取变量类型信息.asp 获取变量类型信息 第12章(/11/) 从中截取字符串.asp 从中截取字符串 切分字符串.asp 切分字符串 删除字符串前后导空格.asp 删除字符串前导空格.asp ...
  • 其核心技术是将文档中所有基本元素的出现信息记录到索引库中, 检索时允许用户采用自然语言表达其检索需求, 并借助截词、邻词等匹配方法直接查阅文献原文信息, 最后将检索结果按相关度排序返回给用户。因而索引...
  • JavaScript王者归来

    2014-11-05 13:59:25
    17.3.1 处理错误信息的ParseError对象 17.3.2 包含错误信息的文档 17.4 XML DOM操作XML文档 17.4.1 访问节点 17.4.2 创建新节点 17.4.3 移动和修改节点及其范例 17.4.4 读写节点属性和读写数据 17.4.5 保存文档 17.5...
  • 4.3.2 串的匹配运算 4.4 文本编辑 习题四 第5章 数组和广义表 5.1 数组的基本概念 5.1.1 数组的概念 5.1.2 数组的顺序表示 5.1.3 特殊矩阵的压缩存储 5.2 稀疏矩阵的三元组存储 5.2.1 三元组表 5.2.2 稀疏...
  • JavaScript笔记

    2018-09-28 11:21:56
    16.Array排序: |--升序:function compare(a,b){return a-b;} |--降序:function compare(a,b){return b-a;} 比较器用法:arr.sort(比较器方法名); 遍历:for(var i=0;i;i++)--等同Java Array倒转:arr....
  • 并设置字段类型获取指定索引的信息修改数据用put请求修改用post请求修改简单的条件查询删除删除索引删除文档复杂查询查询条件封装为对象只查指定的数据字段排序分页查询布尔查询must (类似mysql中的and)should ...
  • 接着,深入探讨了浏览器文档对象模型的发展,详细介绍了JavaScript对象的有关知识,包括对象的属性、方法和事件处理程序等内容。最后,细致地讲述了JavaScript核心语言,包括String,Math,Date和Array等核心对象...
  • 算法设计与分析基础

    2018-02-12 19:26:04
    4.3生成组合对象的算法 4.3.1生成排列 4.3.2生成子集 习题4.3 4.4减常因子算法 4.4.1折半查找 4.4.2假币问题 4.4.3俄式乘法 4.4.4约瑟夫斯问题 习题4.4 4.5减可变规模算法 4.5.1计算中值和选择问题 4.5.2插值查找 ...
  • 然后对四季豆叶片的波段指数值和可识别度进行排序,综合图像的灰度离散、亮度信息丰富和波段的相关性小等特点,得出545、630、645、720、650和570 nm波段有较大的波段指数值和较好的识别度;最后根据最小欧氏距离法...
  • ASP.NET精品课程+源代码

    千次下载 热门讨论 2009-01-05 20:15:51
    《ASP.NET程序设计》课程是一门重要的计算机专业课,它是计算机网络、计算机软件及应用、计算机技术及应用、计算机信息管理、计算机网络管理及维护、电子商务、计算机多媒体技术等专业的一门职业技能型课程,在...
  • python cookbook(第3版)

    2016-01-06 22:24:38
    1.14 排序不支持原生比较的对象 1.15 通过某个字段将记录分组 1.16 过滤序列元素 1.17 从字典中提取子集 1.18 映射名称到序列元素 1.19 转换并同时计算数据 1.20 合并多个字典或映射 第二章:字符串和文本 ...
  • Hibernate实战(第2版 中文高清版)

    热门讨论 2013-03-19 22:45:46
     1.3 持久层和其他层 显示全部信息第一部分 从Hibernate和EJB 3.0开始  第1章 理解对象/关系持久化   1.1 什么是持久化   1.1.1 关系数据库   1.1.2 理解SQL   1.1.3 在Java中使用SQL   1.1.4 面向对象...
  • 《数字视频图像处理与通信》内容详尽,重点突出,注重理论和实践的结合,每章后有习题供读者思考或练习,可作为信息工程、计算机、通信、自动化等专业高年级本科生和研究生教材或教学参考书,也可作为工程技术人员的...
  • VBSCRIP5 -ASP用法详解

    2010-09-23 17:15:46
    Match 对象 提供访问匹配正则表达式的只读属性。 Matches 集合 正则表达式匹配对象的集合。 Mid 函数 从字符串中返回指定数量的字符。 Minute 函数 返回小时内的分钟数,取值范围为 0 至 59。 杂项常数 不能纳入...
  • 10.3 信息安全算法和协议 10.3.1 单向散列函数 10.3.2 时间戳和认证字典 10.3.3 硬币抛掷和比特承诺 10.3.4 安全电子传输(SET)协议 10.3.5 密钥分发和交换 10.4 快速傅里叶变换 10.4.1 本原单位根 10.4.2 离散傅里叶...
  • 实例138 用DataView排序供求信息数据 实例139 使用DataView过滤供求信息数据 实例140 合二为一——合并两个数据集的数据内容 实例141 一分为二——复制数据集 实例142 动态创建DataTable 实例143 DataTable行...
  • 后来在python的正则表达式中找到相关的处理函数compile()(设置匹配对象类型)和findall()(找到所有匹配对象并以list返回)。 功能实现: 第二次排序:在上次的排序中我保留了分类和从小到大的排序。方便提取...
  • 注:本系列图书的第I、II卷再版时均相应改名为《xxx开发实例大全》(基础卷)及(提高卷),但内容基本无变化,需要的童鞋可自由匹配查找。 内容简介  《Java开发实战1200例》分为I、II两卷共计1200个例子,包括了开发...
  • 注:本系列图书的第I、II卷再版时均相应改名为《xxx开发实例大全》(基础卷)及(提高卷),但内容基本无变化,需要的童鞋可自由匹配查找。 内容简介  《Java开发实战1200例》分为I、II两卷共计1200个例子,包括了开发...
  • VBSCRIPT中文手册

    热门讨论 2010-11-12 10:13:06
    Match 对象 提供访问匹配正则表达式的只读属性。 Matches 集合 正则表达式匹配对象的集合。 Mid 函数 从字符串中返回指定数量的字符。 Minute 函数 返回小时内的分钟数,取值范围为 0 至 59。 杂项常数 不能纳入...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 213
精华内容 85
关键字:

对象信息匹配排序