测试开发架构师
测试开发架构师

Java2 - 数据结构

5 数据类型

5.1 整数类型

在Java中，数据类型用于定义变量或表达式可以存储的数据的类型。Java的数据类型可分为两大类：基本数据类型和引用数据类型。

  • byte，字节 【1字节】表示范围：-128 ~ 127 即：-2^7 ~ 2^7 -1
  • short，短整型 【2字节】表示范围：-32768 ~ 32767
  • int，整型 【4字节】表示范围：-2147483648 ~ 2147483647
  • long，长整型 【8字节】表示范围：-9223372036854775808 ~ 9223372036854775807
public class Hello {

    public static void main(String[] args) {
        byte v1 = 32;
        short v2 = 10000;
        int v3 = 22221331;
        long v4 = 554534353424L;
    }
}

需要注意的是，如果直接给 long 变量赋值，Java会将该值默认视为 int 类型，并且当值超出 int 的取值范围时会编译错误。因此，当给 long 变量赋一个超过 int 范围的值时，需要在数字后面加上 L 或 l 后缀，表示这个数字是 long 类型的常量。

**提醒：**逆向时有一些字符串是通过字节数组来表示（UTF-8编码）

v1 = "夏洛"
v2 = [-27, -92, -113, -26, -76, -101]

案例

import java.util.Arrays;

public class Demo {
    public static void main(String[] args) {
        // 1.字节数组（转换为字符串） [字节,字节,字节]
        byte[] dataList = {97, 105, 100, 61, 50, 52, 54, 51, 56, 55, 53, 55, 49, 38, 97, 117, 116, 111, 95, 112, 108, 97, 121, 61, 48, 38, 99, 105, 100, 61, 50, 56, 57, 48, 48, 56, 52, 52, 49, 38, 100, 105, 100, 61, 75, 82, 69, 104, 69, 83, 77, 85, 74, 104, 56, 116, 70, 67, 69, 86, 97, 82, 86, 112, 69, 50, 116, 97, 80, 81, 107, 55, 87, 67, 104, 67, 74, 103, 38, 101, 112, 105, 100, 61, 48, 38, 102, 116, 105, 109, 101, 61, 49, 54, 50, 55, 49, 48, 48, 57, 51, 55, 38, 108, 118, 61, 48, 38, 109, 105, 100, 61, 48, 38, 112, 97, 114, 116, 61, 49, 38, 115, 105, 100, 61, 48, 38, 115, 116, 105, 109, 101, 61, 49, 54, 50, 55, 49, 48, 52, 51, 55, 50, 38, 115, 117, 98, 95, 116, 121, 112, 101, 61, 48, 38, 116, 121, 112, 101, 61, 51};
        String dataString = new String(dataList);
        System.out.println("字符串是：" + dataString);

        // 2.字符串->字节数组
        try {
            /*
            Python中的  name.encode("gbk") 
            string = "夏洛"
            byte_list = list(string.encode("gbk"))
            signed_byte_list = [byte if byte < 128 else byte - 256 for byte in byte_list]
            print(signed_byte_list)
            */
            
            String name = "夏洛";
            byte[] v1 = name.getBytes("GBK");
            System.out.println(Arrays.toString(v1)); //[-49, -60, -62, -27]
		
            // Python中的  name.encode("utf-8")
            byte[] v2 = name.getBytes("UTF-8");
            System.out.println(Arrays.toString(v2)); // [-27, -92, -113, -26, -76, -101]
        } catch (Exception e) {

        }
    }

}

需求来了：某个app逆向，在Java代码中得到一个字节数组 [-49, -60, -62, -27]，请通过Python代码将这个字节数组转换成字符串？

byte_list =[-49, -60, -62, -27]

bs = bytearray()  # python字节数组
for item in byte_list:
    if item < 0:
        item = item + 256
    bs.append(item)

str_data = bs.decode('gbk')  # data = bytes(bs)
print(str_data)
5.2 字符
char v1 = '夏';
char v2 = '洛';
String = "夏洛";

注意：字符串是由多个字符组成。

5.3 字符串

定义字符串

String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：

import java.io.UnsupportedEncodingException;

public class Hello {

    public static void main(String[] args) throws UnsupportedEncodingException {
        String v1 = "夏洛";
        // 用构造函数创建字符串：
        String v2 = new String("夏洛");
        String v4 = new String(new byte[]{-27, -92, -113, -26, -76, -101});
        String v5 = new String(new byte[]{-49, -60, -62, -27}, "GBK");
        String v6 = new String(new char[]{'夏', '洛'}) ;
    }
}

字符串中的方法：

public static void  demo2(){
    String origin = "请叫我靓仔AA";

    int len = origin.length();  // 长度
    for (int i = 0; i < len; i++) {
        char item = origin.charAt(i);
    }

    String v2 = origin.trim(); // 去除空白
    String v3 = origin.toLowerCase(); // 小写
    String v4 = origin.toUpperCase(); // 大写
    String[] v5 = origin.split("我"); // 分割
    String v6 = origin.replace("叫", "喊"); // 替换

    String v7 = origin.substring(2, 6);  // 子字符串=切片 [2:6]
    // equals() 方法用于判断 Number 对象与方法的参数进是否相等
    boolean v8 = origin.equals("请叫我"); // 
    // contains() 方法用于判断字符串中是否包含指定的字符或字符串。
    boolean v9 = origin.contains("el");
    // startsWith() 方法用于检测字符串是否以指定的前缀开始。
    boolean v10 = origin.startsWith("请");
    // concat() 方法用于将指定的字符串参数连接到字符串上。
    String v11 = origin.concat("哈哈哈"); 
}

字符串拼接

出现的点： 对请求参数和请求头 拼接在一起 做加密

import java.io.UnsupportedEncodingException;

public class Hello {

    public static void main(String[] args) {
        // "name=alex&age=18"
        StringBuilder sb = new StringBuilder();  // StringBuffer线程安全
        sb.append("name");
        sb.append("=");
        sb.append("xialuo");
        sb.append("&");
        sb.append("age");
        sb.append("=");
        sb.append("18");
        String dataString = sb.toString();
        System.out.println(dataString);
    }
}

结果输出为：

name=xialuo&age=18

python中的处理方式

data = []
data.append("name")
data.append("=")
data.append("18")
data_string = "".join(data)

Java2 - 数据结构_第1张图片

5.4 数组

存放固定长度的元素。

  • 容器
  • 固定长度
  • 特定类型
import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        // [123,1,999]
        int[] numArray = new int[3];
        numArray[0] = 123;
        numArray[1] = 1;
        numArray[2] = 99;
        System.out.println(Arrays.toString(numArray));
		
        // 同时定义和初始化数组
        String[] names = new String[]{"夏洛", "aa", "bb"};
        System.out.println(Arrays.toString(names));
        
        String[] nameArray = {"夏洛", "aa", "bb"};
        System.out.println(Arrays.toString(nameArray));
	
        // nameArray[0]
        // nameArray.length
        for (int idx = 0; idx < nameArray.length; idx++) {
            String item = nameArray[idx];
        }

    }
}

注意：数组一旦创建个数就不可调整。

5.5 关于Object

  • 在Python中每个类都默认继承Object类（所有的类都是Object的子类）。

  • 在Java所有的类都是默认继承Object类。

    int v1 = 123;
String name = "夏洛";

    用基类可以泛指他的子类的类型。

import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
 
        Object v1 = new String("xialuo");
        System.out.println(v1);
        System.out.println(v1.getClass());

        Object v2 = 123;
        System.out.println(v2);
        System.out.println(v2.getClass());
    }
}

案例一

import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        // 声明数组，数组中元素必须int类型;
        int[] v1 = new int[3];

        // 声明数组，数组中元素必须String类型;
        String[] v2 = new String[3];

        // 声明数组，数组中可以是数组中存储任何类型的对象
        Object[] v3 = new Object[3];
        v3[0] = 123;
        v3[1] = "xialuo";

    }
}

所以，如果以后想要声明的数组中想要是混合类型，就可以用Object来实现。

import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
        // v1是指上字符串对象；String
        String v1 = new String("xialuo");
        String res = v1.toUpperCase();
        System.out.println(res);

        // v2本质是字符串对象；Object
        Object v2 = new String("xialuo");
        String data = (String)v2;
    }
}

案例二

import java.util.Arrays;

public class Hello {

    public static void func(Object v1) {
        // System.out.println(v1);
        // System.out.println(v1.getClass());
        if (v1 instanceof Integer) {
            System.out.println("整型");
        } else if (v1 instanceof String) {
            System.out.println("字符串类型");
        } else {
            System.out.println("未知类型");
        }
    }

    public static void main(String[] args) {
        func(123);
        func("123");
    }
}

6 常见数据类型

6.1 List类型

List是一个接口，接口下面有两个常见的类型（目的是可以存放动态的多个数据）

  • ArrayList，连续的内存地址的存储（内部自动扩容）。

  • LinkedList，底层基于链表实现（自行车链条）。

  • Java中所有的类都继承Object，Object代指所有的类型。

  • 自己创建关系

    Java2 - 数据结构_第2张图片

ArrayList v1 = new ArrayList();  // ArrayList 类实现了可变数组的大小  索引访问
LinkedList v2 = new LinkedList(); //LinkedList 类采用链表结构保存对象，这种结构的优点是便于向集合中插入或者删除元素

List v1 = new ArrayList();
List v2 = new LinkedList();

Object v1 = new ArrayList();  
Object v2 = new LinkedList();

案例一

ArrayList v1 = new ArrayList();
v1.add("夏洛");
v1.add("麻子");

LinkedList v1 = new LinkedList();
v1.add("夏洛");
v1.add("麻子");

Java中接口，是用来约束实现他的类，约束他里面的成员必须有xx。

interface List{
    public void add(Object data);   // 接口中的方法，不写具体的实现，只用于约束。
}

// 类ArrayList实现了接口List，此时这个类就必须有一个add方法。
class ArrayList implements List{
    public void add(Object data){
     	// 将数据data按照连续存储的方法放在内存。
        // ..
    }
}

// 类LinkedList实现了接口List，此时这个类就必须有一个add方法。
class LinkedList implements List{
    public void add(Object data){
     	// 将数据data按照链表的形式存储
        // ..
    }
}

List v1 = new ArrayList();
v1.add("夏洛");
v1.add("麻子");
ArrayList

ArrayList 是 Java 标准库中提供的一个类，它实现了 List 接口，可以用来管理一组对象。ArrayList 的特点是可以无限扩容，因此被广泛用于需要动态添加、删除元素的场景。

  1. 添加元素：
    • add(E element)：在列表末尾添加指定元素。
    • add(int index, E element)：在指定位置插入指定元素。
  2. 获取元素：
    • get(int index)：返回指定位置的元素。
  3. 移除元素：
    • remove(int index)：移除指定位置上的元素。
    • remove(Object obj)：移除第一个匹配指定对象的元素。
  4. 修改元素：
    • set(int index, E element)：替换指定位置上的元素。
  5. 查询和判断：
    • size()：返回列表中的元素数量。
    • isEmpty()：判断列表是否为空。
    • contains(Object obj)：判断列表是否包含指定对象。
  6. 清空和重置：
    • clear()：清空列表，将列表的大小重置为0。
  7. 转换为数组：
    • toArray()：将列表转换为数组。
  8. 遍历：
    • 使用传统的 for 循环、增强的 for-each 循环、迭代器等方式进行遍历。
import java.util.ArrayList;
import java.util.Arrays;

public class Hello {

    public static void main(String[] args) {
		
        // ArrayList，默认内部存放的是混合数据类型。
        
        // ArrayList data = new ArrayList();
        // ArrayList data = new ArrayList();
        
        ArrayList data = new ArrayList();
        data.add("夏洛");
        data.add("aa");
        data.add(666);
        data.add("貂蝉");
		
        String value = data.get(1);
        value.length
            
        // String value = (String) data.get(1);
        Object temp = data.get(1);
        String value = (String) temp; // 转化可转换的数据
            
        System.out.println(value);

        int xo = (int) data.get(2);
        System.out.println(xo);

        data.set(0, "哈哈哈哈");
        System.out.println(data);

        data.remove("eric");
        data.remove(0);
        System.out.println(data);
		
        int size = data.size();
        System.out.println(size);
		
        boolean exists = data.contains("莹莹");
        System.out.println(exists);

		
        for (Object item : data) {
            System.out.println(item);
        }

        for (int i = 0; i < data.size(); i++) {
            Object item = data.get(i);
            System.out.println(item);
        }
    }
}
 
  
LinkedList
 
  
LinkedList 是 Java 中的链表实现类，它实现了 List 接口和 Deque 接口，提供了对链表结构的支持。下面是一些 LinkedList 常用的方法：
 
  
     
   
  1. 添加元素： 
    
       
     
    • add(E element)：在链表末尾添加指定元素。
      •  
     
    • add(int index, E element)：在指定位置插入指定元素。
      •  
    
     
    2.  
   
  2. 获取元素： 
    
       
     
    • get(int index)：返回指定位置的元素。
      •  
     
    • getFirst()：返回链表的第一个元素。
      •  
     
    • getLast()：返回链表的最后一个元素。
      •  
    
     
    3.  
   
  3. 移除元素： 
    
       
     
    • remove(int index)：移除指定位置上的元素。
      •  
     
    • remove(Object obj)：移除第一个匹配指定对象的元素。
      •  
     
    • removeFirst()：移除链表的第一个元素。
      •  
     
    • removeLast()：移除链表的最后一个元素。
      •  
    
     
    4.  
   
  4. 修改元素： 
    
       
     
    • set(int index, E element)：替换指定位置上的元素。
      •  
    
     
    5.  
   
  5. 查询和判断： 
    
       
     
    • size()：返回链表中的元素数量。
      •  
     
    • isEmpty()：判断链表是否为空。
      •  
     
    • contains(Object obj)：判断链表是否包含指定对象。
      •  
    
     
    6.  
   
  6. 清空和重置： 
    
       
     
    • clear()：清空链表。
      •  
    
     
    7.  
   
  7. 队列操作： 
    
       
     
    • offer(E element)：将元素添加到链表末尾，相当于队列的入队操作。
      •  
     
    • poll()：移除并返回链表第一个元素，相当于队列的出队操作。
      •  
    
     
    8.  
   
  8. 栈操作： 
    
       
     
    • push(E element)：将元素添加到链表的开头，相当于栈的入栈操作。
      •  
     
    • pop()：移除并返回链表的第一个元素，相当于栈的出栈操作。
      •  
    
     
    9.  
   
  9. 遍历： 
    
       
     
    • 使用传统的 for 循环、增强的 for-each 循环、迭代器等方式进行遍历。
      •  
    
     
    10.  
  
 
  
import java.util.LinkedList;

public class Hello {

    public static void main(String[] args) {
        LinkedList<Integer> v1 = new LinkedList<Integer>();
        v1.add(11);
        v1.add(22);

        LinkedList<Object> v2 = new LinkedList<Object>();
        v2.add("有阪深雪");
        v2.add("大桥未久");
        v2.add(666);
        v2.add(123);

        //v2.remove(1);
        //v2.remove("哈哈");

        v2.set(2, "苍老师");
        v2.push("哈哈哈");
        // v2.addFirst(11);


        for (int i = 0; i < v2.size(); i++) {
            Object item = v2.get(i);
            System.out.println(item);
        }

        for (Object item : v2) {
            System.out.println(item);
        }
    }
}

 
  
关于迭代器：
 
  
在Java中，迭代器（Iterator）是用于遍历集合（Collection）或数据结构中元素的接口。通过使用迭代器，我们可以按顺序访问集合中的每个元素，而无需了解底层集合的内部实现。
 
  
import java.util.ArrayList;
import java.util.Iterator;

public class IteratorExample {
    public static void main(String[] args) {
        // 创建一个ArrayList集合
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");

        // 获取集合的迭代器
        Iterator<String> iterator = list.iterator();

        // 使用迭代器遍历集合元素
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

 
  
在上面的代码中，我们创建了一个ArrayList集合并添加了一些元素。然后，通过调用iterator()方法获取了集合的迭代器对象，并使用hasNext()和next()方法进行迭代遍历。hasNext()方法用于检查是否还有下一个元素，next()方法用于返回当前元素并移动到下一个元素。
 
  
需要注意的是，在使用迭代器遍历集合时，如果在遍历过程中修改了集合的结构（例如添加或删除元素），会抛出ConcurrentModificationException异常。因此，建议在使用迭代器遍历集合时不要对集合进行修改操作。
 
  
迭代器是Java中常用的遍历集合的方式，它提供了一种统一的、可移植的遍历接口，并且支持在遍历过程中删除元素，是Java集合框架中重要的一部分。
 
  
6.2 set系列
 
  
Set是一个接口，常见实现这个接口的有两个类，用于实现不重复的多元素集合。
 
  
     
   
  • HashSet，去重，无序。
    •  
   
  • TreeSet，去重，内部默认排序（ascii、unicode）【不同的数据类型，无法进行比较】。
    •  
  
 
  
import java.util.*;

public class Hello {

    public static void main(String[] args) {
        /*
方式一："HashSet s1 = new HashSet();" 使用具体的HashSet类作为声明类型，创建一个HashSet对象。这种方式限定了变量s1的类型为HashSet，只能调用HashSet类特有的方法。

方式二："Set s1 = new HashSet();" 使用Set接口作为声明类型，创建一个HashSet对象。这种方式使用了接口类型Set，可以调用Set接口中定义的所有方法，但无法直接调用HashSet类特有的方法。这种方式更加灵活，便于后续切换到其他实现Set接口的类，如TreeSet或LinkedHashSet。

方式三："HashSet s1 = new HashSet();" 使用泛型来指定集合中元素的类型。这种方式将HashSet限定为存储String类型的元素，可以确保在编译时期进行类型检查，避免插入不合法的元素类型到集合中。
        */
        // HashSet s1 = new HashSet();
        // Set s1 = new HashSet();
        // HashSet s1 = new HashSet();
        HashSet s1 = new HashSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");
        s1.add("P站");
        s1.add(666);
        System.out.println(s1); // [B站, A站, P站,666]
		
        // s2 = {"东京热","东北热","南京热"}
        HashSet s2 = new HashSet(){
            {
                add("东京热");
                add("东北热");
                add("南京热");
            }
        };
        System.out.println(s2); // [B站, A站, P站]



        // Set s2 = new TreeSet();
        // TreeSet s2 = new TreeSet();
        TreeSet s3 = new TreeSet();
        s3.add("P站");
        s3.add("B站");
        s3.add("A站");
        s3.add("P站");
        // s3.add(666); //不可以

        System.out.println(s3); // [B站, A站, P站]

        TreeSet s4 = new TreeSet(){
            {
                add("P站");
                add("B站");
                add("A站");
                add("P站");
            }
        };
        System.out.println(s4); // [B站, A站, P站]

    }
}

 
  
关于交并差：
 
  
import java.util.*;

public class Hello {

    public static void main(String[] args) {
        // Set s1 = new HashSet();
        HashSet s1 = new HashSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");
        s1.remove("P站");
        System.out.println(s1); // [B站, A站, P站]

        boolean exists = s1.contains("B站");
        System.out.println(exists);

        HashSet s2 = new HashSet();
        s2.add(123);
        s2.add(456);

        HashSet v1 = new HashSet(); // 空 
        v1.addAll(s1);
        v1.retainAll(s2); // 交集 & 
        System.out.println(v1);


        HashSet v2 = new HashSet();
        v2.addAll(s1);
        v2.addAll(s2); // 并集 |
        System.out.println(v2);

        HashSet v3 = new HashSet();
        v3.addAll(s1);
        v3.removeAll(s2); // 差集 s1 - s2
        System.out.println(v3);


        HashSet v4 = new HashSet();
        v4.addAll(s2);
        v4.removeAll(s1); // 差集 s2 - s1
        System.out.println(v4);
    }
}

 
  
关于循环获取：
 
  
import java.util.*;

public class Hello {

    public static void main(String[] args) {

        TreeSet s1 = new TreeSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");

        for (Object item : s1) {
            System.out.println(item);
        }
    }
}

 
  
关于迭代器：
 
  
使用Set集合的iterator()方法获取一个迭代器对象
 
  
使用hasNext()方法检查迭代器是否有下一个元素。如果有，则执行相应的操作；如果没有，则退出循环。
 
  
在循环内部，可以通过next()方法获取当前迭代器指向的元素
 
  
import java.util.*;

public class Hello {

    public static void main(String[] args) {

        TreeSet s1 = new TreeSet();
        s1.add("P站");
        s1.add("B站");
        s1.add("A站");

        Iterator it = s1.iterator();
        while (it.hasNext()) {
            String item = (String) it.next();
            System.out.println(item);
        }
    }
}

 
  
6.3 map系列
 
  
Map是一个接口，常见实现这个接口的有两个类，用于存储键值对。
 
  
     
   
  •  
    HashMap，是基于哈希表实现的Map，它提供了快速的插入、查找和删除操作。键值对的存储是无序的，在大部分情况下是最常用的Map实现类。
     
    •  
   
  •  
    TreeMap，默认根据key排序。（常用）
     
    •  
  
 
  
HashMap
 
  
import java.util.*;

public class Hello {

    public static void main(String[] args) {
        HashMap h1 = new HashMap();
        h1.put("name","xialuo");
        h1.put("age",18);
        h1.put("hobby","男");
        System.out.println(h1); 
		
        // 特定数据类型  字符串
        HashMap<String,String> h2 = new HashMap<String,String>();
        h2.put("name","xialuo");
        h2.put("age","18");
        h2.put("hobby","男");
        System.out.println(h2); 
		
        // 声明 初始化值 
        HashMap<String,String> h3 = new HashMap<String,String>(){
            {
                put("name","xialuo");
                put("age","18");
                put("hobby","男");
            }
        };
        System.out.println(h3);
    }
}

 
  
TreeMap
 
  
TreeMap 是 Map 接口的一个实现类，它基于红黑树（Red-Black Tree）实现，可以保持键的有序性。相比于 Map 接口中通用的方法，TreeMap 中具有以下一些特有的方法：
 
  
     
   
  1. firstKey()：返回最小键。
    2.  
   
  2. lastKey()：返回最大键。
    3.  
   
  3. floorKey(K key)：返回小于等于指定键的最大键，如果不存在这样的键，则返回 null。
    4.  
   
  4. ceilingKey(K key)：返回大于等于指定键的最小键，如果不存在这样的键，则返回 null。
    5.  
   
  5. lowerKey(K key)：返回小于指定键的最大键，如果不存在这样的键，则返回 null。
    6.  
   
  6. higherKey(K key)：返回大于指定键的最小键，如果不存在这样的键，则返回 null。
    7.  
   
  7. descendingKeySet()：返回按逆序遍历此映射中的键所构成的集合。
    8.  
  
 
  
import java.util.*;

public class Hello {

    public static void main(String[] args) {
        
        TreeMap h1 = new TreeMap(); // 改为了TreeMap
        h1.put("name","xialuo");
        h1.put("age",18);
        h1.put("hobby","男");
        System.out.println(h1); // {age=18, hobby=男, name=xialuo}
		
        // 固定类型
        TreeMap<String,String> h2 = new TreeMap<String,String>();
        h2.put("name","xialuo");
        h2.put("age","18");
        h2.put("hobby","男");
        System.out.println(h2); 
		
		// 声明 初始化值 
        TreeMap<String,String> h3 = new TreeMap<String,String>(){
            {
                put("name","xialuo");
                put("age","18");
                put("hobby","男");
            }
        };
        System.out.println(h3);
		
		// 只能调用 Map 接口中定义的方法，不能直接调用 TreeMap 特有的方法
        Map h4 = new TreeMap();
        h4.put("name","xialuo");
        h4.put("age",18);
        h4.put("hobby","男");
        System.out.println(h4);
        // h4.firstKey();
    }
}

 
  
python中使用需要排序处理
 
  
在Python中需要自己处理key排序的问题。
v4 = {
	"aid":123,
	"xx":999,
	"wid":888
}

# 1.python 根据key进行排序
# data = ["{}={}".format(key,v4[key])  for key in sorted(v4.keys())]

# 2.再进行拼接
# result = "&".join(data)

result = "&".join(["{}={}".format(key,v4[key])  for key in sorted(v4.keys())])

 
  
TreeMap常见操作：
 
  
import java.util.*;

public class Hello {

    public static void main(String[] args) {
        TreeMap h1 = new TreeMap(); // 改为了TreeMap
        h1.put("name", "xialuo");
        h1.put("age", "18");
        h1.put("hobby", "男");
        h1.put("hobby", "女人");
	
        h1.remove("age");
        int size = h1.size();

        Object value = h1.get("name"); // 不存在，返回null
        System.out.println(value);

        boolean existsKey = h1.containsKey("age");
        boolean existsValue = h1.containsValue("xialuo");
		
        // 替换
        h1.replace("name", "李杰");
        System.out.println(h1);


        // 循环: 示例1
        // {  ("name", "xialuo")，("age", "18"),  }
        Set<Map.Entry<String, String>> s1 = h1.entrySet();
        Iterator it1 = s1.iterator();
        while (it1.hasNext()) {
            // ("name", "xialuo")
            Map.Entry<String, String> entry = (Map.Entry<String, String>) it1.next();
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
        }

        // 循环: 示例2
        Set s2 = h1.entrySet();
        Iterator it2 = s2.iterator();
        while (it2.hasNext()) {
            Map.Entry entry = (Map.Entry) it2.next();
            String k = (String) entry.getKey();
            String v = (String) entry.getValue();
        }

        // 循环: 示例3
        TreeMap<String, String> h2 = new TreeMap<String, String>(); // 改为了TreeMap
        h2.put("name", "xialuo");
        h2.put("age", "18");
        for (Map.Entry<String, String> entry : h2.entrySet()) {
            String k = entry.getKey();
            String v = entry.getValue();
        }

        // 循环: 示例4
        TreeMap h3 = new TreeMap(); // 改为了TreeMap
        h3.put("name", "xialuo");
        h3.put("age", 18);
        
        for (Object entry : h3.entrySet()) {
            Map.Entry<String, Object> entryMap = (Map.Entry<String, Object>) entry;
            String k = entryMap.getKey();
            Object v = entryMap.getValue(); // 18   "xialuo"
            
            if (v instanceof Integer) {
                System.out.println("数字：" + Integer.toString((Integer) v));
            } else if (v instanceof String) {
                System.out.println("字符串：" + (String) v);
            } else {
                System.out.println("未知类型：" + v.toString());
            }
        }
    }
}

 
  
尝试用python还原
 
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(安卓爬虫逆向,java,数据结构,python)

        

            

                
    
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • python os.environ
                        江湖偌大
python深度学习
                        
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
    
                    
    • 
                    
  • Python中os.environ基本介绍及使用方法
                        鹤冲天Pro
#Pythonpython服务器开发语言
                        
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
    
                    
    • 
                    
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验
                        我的运维人生
信息可视化数据分析数据挖掘运维开发技术共享
                        
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
    
                    
    • 
                    
  • Python教程：一文了解使用Python处理XPath
                        旦莫
Python进阶python开发语言
                        
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
    
                    
    • 
                    
  • python os.environ_python os.environ 读取和设置环境变量
                        weixin_39605414
pythonos.environ
                        
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 使用Faiss进行高效相似度搜索
                        llzwxh888
faisspython
                        
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
    
                    
    • 
                    
  • python是什么意思中文-在python中%是什么意思
                        编程大乐趣

                        
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
    
                    
    • 
                    
  • 数组去重
                        好奇的猫猫猫

                        
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • python八股文面试题分享及解析(1)
                        Shawn________
python
                        
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
    
                    
    • 
                    
  • 每日算法&面试题，大厂特训二十八天——第二十天（树）
                        肥学
⚡算法题⚡面试题每日精进java算法数据结构
                        
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
    
                    
    • 
                    
  • Python快速入门 —— 第三节：类与对象
                        孤华暗香
Python快速入门python开发语言
                        
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
    
                    
    • 
                    
  • pyecharts——绘制柱形图折线图
                        2224070247
信息可视化pythonjava数据可视化
                        
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • 回溯算法-重新安排行程
                        chirou_
算法数据结构图论c++图搜索
                        
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
    
                    
    • 
                    
  • Python 实现图片裁剪（附代码） | Python工具
                        剑客阿良_ALiang

                        
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
    
                    
    • 
                    
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4)
                        算法大师
华为od面试python
                        
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
    
                    
    • 
                    
  • python os 环境变量
                        CV矿工
python开发语言numpy
                        
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
    
                    
    • 
                    
  • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
    
                    
    • 
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • Faiss：高效相似性搜索与聚类的利器
                        网络·魚
大数据faiss
                        
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
    
                    
    • 
                                
  • ASM系列四 利用Method 组件动态注入方法逻辑
                                    lijingyao8206
字节码技术jvmAOP动态代理ASM
                                    
            这篇继续结合例子来深入了解下Method组件动态变更方法字节码的实现。通过前面一篇，知道ClassVisitor 的visitMethod()方法可以返回一个MethodVisitor的实例。那么我们也基本可以知道，同ClassVisitor改变类成员一样，MethodVIsistor如果需要改变方法成员，注入逻辑，也可以
    
                                
    • 
                                
  • java编程思想 --内部类
                                    百合不是茶
java内部类匿名内部类
                                    
    内部类;了解外部类 并能与之通信 内部类写出来的代码更加整洁与优雅 
  
1,内部类的创建  内部类是创建在类中的 
 
package com.wj.InsideClass;

/*
 * 内部类的创建
 */
public class CreateInsideClass {

	public CreateInsideClass(
    
                                
    • 
                                
  • web.xml报错
                                    crabdave
web.xml
                                    
    web.xml报错 
  
The content of element type "web-app" must match "(icon?,display- 
 name?,description?,distributable?,context-param*,filter*,filter-mapping*,listener*,servlet*,s
    
                                
    • 
                                
  • 泛型类的自定义
                                    麦田的设计者
javaandroid泛型
                                    
       为什么要定义泛型类，当类中要操作的引用数据类型不确定的时候。 
采用泛型类，完成扩展。 
  例如有一个学生类 
    
Student{
  Student(){
   System.out.println("I'm a student.....");
  }
} 
 有一个老师类 
  

    
                                
    • 
                                
  • CSS清除浮动的4中方法
                                    IT独行者
JavaScriptUIcss
                                    
    清除浮动这个问题，做前端的应该再熟悉不过了，咱是个新人，所以还是记个笔记，做个积累，努力学习向大神靠近。CSS清除浮动的方法网上一搜，大概有N多种，用过几种，说下个人感受。 
1、结尾处加空div标签 clear:both      1   2   3   4      
.div 
1 
{ 
background 
: 
#000080 
; 
border 
: 
1px   
s
    
                                
    • 
                                
  • Cygwin使用windows的jdk 配置方法
                                    _wy_
jdkwindowscygwin
                                    
    1.[vim /etc/profile] 
   JAVA_HOME="/cgydrive/d/Java/jdk1.6.0_43"  (windows下jdk路径为D:\Java\jdk1.6.0_43) 
   PATH="$JAVA_HOME/bin:${PATH}" 
   CLAS
    
                                
    • 
                                
  • linux下安装maven
                                    无量
mavenlinux安装
                                    
    Linux下安装maven(转)  1.首先到Maven官网 
下载安装文件，目前最新版本为3.0.3，下载文件为 
apache-maven-3.0.3-bin.tar.gz，下载可以使用wget命令； 
 
2.进入下载文件夹，找到下载的文件，运行如下命令解压 
  tar -xvf  apache-maven-2.2.1-bin.tar.gz  
解压后的文件夹
    
                                
    • 
                                
  • tomcat的https 配置,syslog-ng配置
                                    aichenglong
tomcathttp跳转到httpssyslong-ng配置syslog配置
                                    
    1) tomcat配置https,以及http自动跳转到https的配置 
    1)TOMCAT_HOME目录下生成密钥(keytool是jdk中的命令) 
     keytool -genkey -alias tomcat -keyalg RSA -keypass changeit -storepass changeit
    
                                
    • 
                                
  • 关于领号活动总结
                                    alafqq
活动
                                    
    关于某彩票活动的总结 
具体需求，每个用户进活动页面，领取一个号码，1000中的一个； 
活动要求 
1，随机性，一定要有随机性； 
2，最少中奖概率，如果注数为3200注，则最多中4注 
3，效率问题，（不能每个人来都产生一个随机数，这样效率不高）； 
4，支持断电（仍然从下一个开始），重启服务；（存数据库有点大材小用，因此不能存放在数据库） 
 
解决方案 
1，事先产生随机数1000个，并打
    
                                
    • 
                                
  • java数据结构 冒泡排序的遍历与排序
                                    百合不是茶
java
                                    
    java的冒泡排序是一种简单的排序规则 
  
冒泡排序的原理：  
         比较两个相邻的数，首先将最大的排在第一个，第二次比较第二个 ，此后一样； 
        针对所有的元素重复以上的步骤，除了最后一个 
  
  
例题；将int array[] 
    
                                
    • 
                                
  • JS检查输入框输入的是否是数字的一种校验方法
                                    bijian1013
js
                                    
    如下是JS检查输入框输入的是否是数字的一种校验方法： 
<form method=post target="_blank">
   数字：<input type="text" name=num onkeypress="checkNum(this.form)"><br>
</form>

    
                                
    • 
                                
  • Test注解的两个属性：expected和timeout
                                    bijian1013
javaJUnitexpectedtimeout
                                    
    JUnit4：Test文档中的解释： 
　　The Test annotation supports two optional parameters. 
　　The first, expected, declares that a test method should throw an exception. 
　　If it doesn't throw an exception or if it 
    
                                
    • 
                                
  • [Gson二]继承关系的POJO的反序列化
                                    bit1129
POJO
                                    
    父类 
  
  
package inheritance.test2;

import java.util.Map;

public class Model {
    private String field1;
    private String field2;

    private Map<String, String> infoMap
    
                                
    • 
                                
  • 【Spark八十四】Spark零碎知识点记录
                                    bit1129
spark
                                    
    1. ShuffleMapTask的shuffle数据在什么地方记录到MapOutputTracker中的 
ShuffleMapTask的runTask方法负责写数据到shuffle map文件中。当任务执行完成成功，DAGScheduler会收到通知，在DAGScheduler的handleTaskCompletion方法中完成记录到MapOutputTracker中 
  
   
    
                                
    • 
                                
  • WAS各种脚本作用大全
                                    ronin47
WAS 脚本
                                    
    　　　http://www.ibm.com/developerworks/cn/websphere/library/samples/SampleScripts.html 
　　　无意中，在WAS官网上发现的各种脚本作用，感觉很有作用，先与各位分享一下 
　　　 
获取下载 
这些示例 jacl 和 Jython 脚本可用于在 WebSphere Application Server 的不同版本中自
    
                                
    • 
                                
  • java-12.求 1+2+3+..n不能使用乘除法、 for 、 while 、 if 、 else 、 switch 、 case 等关键字以及条件判断语句
                                    bylijinnan
switch
                                    
    借鉴网上的思路，用java实现： 
 




public class NoIfWhile {

	/**
	 * @param args
	 * 
	 * find x=1+2+3+....n
	 */
	public static void main(String[] args) {
		int n=10;
		int re=find(n);
		System.o
    
                                
    • 
                                
  • Netty源码学习-ObjectEncoder和ObjectDecoder
                                    bylijinnan
javanetty
                                    
    Netty中传递对象的思路很直观： 
Netty中数据的传递是基于ChannelBuffer（也就是byte[]）； 
那把对象序列化为字节流，就可以在Netty中传递对象了 
相应的从ChannelBuffer恢复对象，就是反序列化的过程 
 
Netty已经封装好ObjectEncoder和ObjectDecoder 
 
先看ObjectEncoder 
ObjectEncoder是往外发送
    
                                
    • 
                                
  • spring 定时任务中cronExpression表达式含义
                                    chicony
cronExpression
                                    
    一个cron表达式有6个必选的元素和一个可选的元素，各个元素之间是以空格分隔的，从左至右，这些元素的含义如下表所示： 
代表含义            是否必须 允许的取值范围         &nb
    
                                
    • 
                                
  • Nutz配置Jndi
                                    ctrain
JNDI
                                    
    1、使用JNDI获取指定资源： 
 

var ioc = {
    dao : {
        type :"org.nutz.dao.impl.NutDao",
        args : [ {jndi :"jdbc/dataSource"} ]
    }
}
 
以上方法,仅需要在容器中配置好数据源,注入到NutDao即可. 
    
                                
    • 
                                
  • 解决 /bin/sh^M: bad interpreter: No such file or directory
                                    daizj
shell
                                    
    在Linux中执行.sh脚本，异常/bin/sh^M: bad interpreter: No such file or directory。 
  
分析：这是不同系统编码格式引起的：在windows系统中编辑的.sh文件可能有不可见字符，所以在Linux系统下执行会报以上异常信息。 
解决： 
1）在windows下转换： 
利用一些编辑器如UltraEdit或EditPlus等工具
    
                                
    • 
                                
  • [转]for 循环为何可恨？
                                    dcj3sjt126com
程序员读书
                                    
      
Java的闭包(Closure)特征最近成为了一个热门话题。 一些精英正在起草一份议案，要在Java将来的版本中加入闭包特征。 然而，提议中的闭包语法以及语言上的这种扩充受到了众多Java程序员的猛烈抨击。 
不久前，出版过数十本编程书籍的大作家Elliotte Rusty Harold发表了对Java中闭包的价值的质疑。 尤其是他问道“for 循环为何可恨？”[http://ju
    
                                
    • 
                                
  • Android实用小技巧
                                    dcj3sjt126com
android
                                    
    1、去掉所有Activity界面的标题栏 
　　修改AndroidManifest.xml 　　在application 标签中添加android:theme="@android:style/Theme.NoTitleBar" 
  
2、去掉所有Activity界面的TitleBar 和StatusBar  
　　修改AndroidManifes
    
                                
    • 
                                
  • Oracle 复习笔记之序列
                                    eksliang
Oracle 序列sequenceOracle sequence
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2098859 
1.序列的作用 
 
 序列是用于生成唯一、连续序号的对象 
 一般用序列来充当数据库表的主键值 
 
2.创建序列语法如下： 
  
create sequence s_emp
start with 1      --开始值
increment by 1    --増长值
maxval
    
                                
    • 
                                
  • 有“品”的程序员
                                    gongmeitao
工作
                                    
    完美程序员的10种品质　　 
  
 完美程序员的每种品质都有一个范围，这个范围取决于具体的问题和背景。没有能解决所有问题的 
  
完美程序员（至少在我们这个星球上），并且对于特定问题，完美程序员应该具有以下品质： 
　　1. 才智非凡- 能够理解问题、能够用清晰可读的代码翻译并表达想法、善于分析并且逻辑思维能力强 
  
（范围：用简单方式解决复杂问题）　　 
 
    
                                
    • 
                                
  • 使用KeleyiSQLHelper类进行分页查询
                                    hvt
sql.netC#asp.nethovertree
                                    
    本文适用于sql server单主键表或者视图进行分页查询，支持多字段排序。KeleyiSQLHelper类的最新代码请到http://hovertree.codeplex.com/SourceControl/latest下载整个解决方案源代码查看。或者直接在线查看类的代码：http://hovertree.codeplex.com/SourceControl/latest#HoverTree.D
    
                                
    • 
                                
  • SVG 教程 （三）圆形，椭圆，直线
                                    天梯梦
svg
                                    
    SVG <circle>   SVG 圆形 - <circle> 
<circle> 标签可用来创建一个圆： 
下面是SVG代码： 
<svg xmlns="http://www.w3.org/2000/svg" version="1.1">
  <circle cx="100" c
    
                                
    • 
                                
  • 链表栈
                                    luyulong
java数据结构
                                    
    
public class Node {
	private Object object;
	private Node next;

	public Node() {
		this.next = null;
		this.object = null;
	}

	public Object getObject() {
		return object;
	}

	public
    
                                
    • 
                                
  • 基础数据结构和算法十：2-3 search tree
                                    sunwinner
Algorithm2-3 search tree
                                    
      
Binary search tree works well for a wide variety of applications, but they have poor worst-case performance. Now we introduce a type of binary search tree where costs are guaranteed to be loga
    
                                
    • 
                                
  • spring配置定时任务
                                    stunizhengjia
springtimer
                                    
    最近因工作的需要，用到了spring的定时任务的功能,觉得spring还是很智能化的,只需要配置一下配置文件就可以了,在此记录一下，以便以后用到： 
  
  
//------------------------定时任务调用的方法------------------------------
    /**
     * 存储过程定时器
    */
    publi
    
                                
    • 
                                
  • ITeye 8月技术图书有奖试读获奖名单公布
                                    ITeye管理员
活动
                                    
    ITeye携手博文视点举办的8月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 
 
 
8月试读活动回顾： 
http://webmaster.iteye.com/blog/2102830 
 
 
本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 
 
 
《跨终端Web》 
 
 
 
 gleams：http
    
                                
    •