精华内容
下载资源
问答
  • 当爬虫程序或采集软件配置代理之后,如何判断代理IP使用成功了呢?可以使用查询IP地址网站进行协助,例如使用代理IP去搜索百度IP或者访问https://www.ip138.com,这网站会将HTTP请求的来源IP获取并通过HTTP...

    当爬虫程序或采集软件配置代理之后,如何判断代理IP使用成功了呢?可以使用查询IP地址这类网站进行协助,例如使用代理IP去搜索百度IP或者访问https://www.ip138.com,这类网站会将HTTP请求的来源IP获取并通过HTTP内容返回,因此如果代理IP转发成功,目标网站返回的内容就应该是代理IP地址。一般会有下面几种情况:
    1、代理直接转发
    只要将返回的IP地址复制进入百度IP或者https://www.ip138.com进行检查,如果是爬虫服务器的IP地址表示代理IP转发失败,否则就表示代理IP转发成功。
    2、代理多次转发
    查询IP地址网站返回的内容,既不是爬虫服务器的IP地址,也不是爬虫程序或采集软件直接使用的代理IP地址,而是经过代理IP多次转发后,最后请求IP地址网站的代理IP地址。
    3、代理自动转发
    部分代理IP产品,会根据爬虫程序或采集软件的每个HTTP请求,自动分配不同的代理IP进行转发,出现每一次查询获取的IP地址都不一样,这样就能在数据采集的过程中,突破目标网站的IP限制行为。要注意这其中又会出现更复杂的情况是,部分IP查询网站会按照cookie等信息直接缓存返回内容,即使代理IP每次请求都会转发不同IP,这类IP查询网站也会返回重复的IP地址,造成代理IP自动转发失败的假象,下面提供demo 示例如下:

    package main
            import (
                "net/url"
                "net/http"
                "bytes"
                "fmt"
                "io/ioutil"
            )
            // 代理服务器(产品官网 www.16yun.cn)
            const ProxyServer = "t.16yun.cn:31111"
            type ProxyAuth struct {
                Username string
                Password string
            }
            func (p ProxyAuth) ProxyClient() http.Client {
                var proxyURL *url.URL
                if p.Username != ""&& p.Password!="" {
                    proxyURL, _ = url.Parse("http://" + p.Username + ":" + p.Password + "@" + ProxyServer)
                }else{
                    proxyURL, _ = url.Parse("http://" + ProxyServer)
                }
                return http.Client{Transport: &http.Transport{Proxy:http.ProxyURL(proxyURL)}}
            }
            func main()  {
                targetURI := "https://httpbin.org/ip"
                // 初始化 proxy http client
                client := ProxyAuth{"username",  "password"}.ProxyClient()
                request, _ := http.NewRequest("GET", targetURI, bytes.NewBuffer([] byte(``)))
                // 设置Proxy-Tunnel
                // rand.Seed(time.Now().UnixNano())
                // tunnel := rand.Intn(10000)
                // request.Header.Set("Proxy-Tunnel", strconv.Itoa(tunnel) )
                response, err := client.Do(request)
                if err != nil {
                    panic("failed to connect: " + err.Error())
                } else {
                    bodyByte, err := ioutil.ReadAll(response.Body)
                    if err != nil {
                        fmt.Println("读取 Body 时出错", err)
                        return
                    }
                    response.Body.Close()
                    body := string(bodyByte)
                    fmt.Println("Response Status:", response.Status)
                    fmt.Println("Response Header:", response.Header)
                    fmt.Println("Response Body:\n", body)
                }
            }
    
    展开全文
  • 很多初次用代理IP的小伙伴都会有这样的疑惑:在爬虫程序或采集软件上配置代理后,该如何判断代理IP是否使用成功了呢?天启IP告诉你! 其实可以借助查询IP地址的这网站,使用代理IP后,再去浏览器搜索百度IP或者...

    很多初次用代理IP的小伙伴都会有这样的疑惑:在爬虫程序或采集软件上配置代理后,该如何判断代理IP是否使用成功了呢?天启IP告诉你!在这里插入图片描述

    其实可以借助查询IP地址的这类网站,使用代理IP后,再去浏览器搜索百度IP或者访问https://www.ip138.com。这类网站会将HTTP请求的来源IP获取并通过HTTP内容返回,如果代理IP转发成功,目标网站返回的内容就应该是代理IP地址。一般会有下面几种情况:

    1、代理直接转发

    只要将返回的IP地址复制进入百度IP或者https://www.ip138.com进行检查,如果是爬虫服务器的IP地址表示代理IP转发失败,否则就表示代理IP转发成功。

    2、代理多次转发

    查询IP地址网站返回的内容,既不是爬虫服务器的IP地址,也不是爬虫程序或采集软件直接使用的代理IP地址,而是经过代理IP多次转发后,最后请求IP地址网站的代理IP地址。

    3、代理自动转发

    部分代理IP产品,会根据爬虫程序或采集软件的每个HTTP请求,自动分配不同的代理IP进行转发,出现每一次查询获取的IP地址都不一样,这样就能在数据采集的过程中,突破目标网站的IP限制行为。要注意这其中又会出现更复杂的情况是,部分IP查询网站会按照cookie等信息直接缓存返回内容,即使代理IP每次请求都会转发不同IP,这类IP查询网站也会返回重复的IP地址,造成代理IP自动转发失败的假象,下面提供demo 示例如下:

    package main

        import (
    
            "net/url"
    
            "net/http"
    
            "bytes"
    
            "fmt"
    
            "io/ioutil"
    
        )
    
        // 代理服务器(产品官网 www.16yun.cn)
    
        const ProxyServer = "t.16yun.cn:31111"
    
        type ProxyAuth struct {
    
            Username string
    
            Password string
    
        }
    
        func (p ProxyAuth) ProxyClient() http.Client {
    
            var proxyURL *url.URL
    
            if p.Username != ""&& p.Password!="" {
    
                proxyURL, _ = url.Parse("http://" + p.Username + ":" + p.Password + "@" + ProxyServer)
    
            }else{
    
                proxyURL, _ = url.Parse("http://" + ProxyServer)
    
            }
    
            return http.Client{Transport: &http.Transport{Proxy:http.ProxyURL(proxyURL)}}
    
        }
    
        func main()  {
    
            targetURI := "https://httpbin.org/ip"
    
            // 初始化 proxy http client
    
            client := ProxyAuth{"username",  "password"}.ProxyClient()
    
            request, _ := http.NewRequest("GET", targetURI, bytes.NewBuffer([] byte(``)))
    
            // 设置Proxy-Tunnel
    
            // rand.Seed(time.Now().UnixNano())
    
            // tunnel := rand.Intn(10000)
    
            // request.Header.Set("Proxy-Tunnel", strconv.Itoa(tunnel) )
    
            response, err := client.Do(request)
    
            if err != nil {
    
                panic("failed to connect: " + err.Error())
    
            } else {
    
                bodyByte, err := ioutil.ReadAll(response.Body)
    
                if err != nil {
    
                    fmt.Println("读取 Body 时出错", err)
    
                    return
    
                }
    
                response.Body.Close()
    
                body := string(bodyByte)
    
                fmt.Println("Response Status:", response.Status)
    
                fmt.Println("Response Header:", response.Header)
    
                fmt.Println("Response Body:\n", body)
    
            }
    
        }
    
    展开全文
  • 如何判断两个对象相等,这个问题实际上可以看做是如何对equals方法和hashcode方法的理解。 从以下个点来理解equals和hashCode方法: 1、equals的作用及与==的区别。 2、hashcode的作用及与equals的关系。 1、...
    • 如何判断两个对象相等,这个问题实际上可以看做是如何对equals方法和hashcode方法的理解。
      从以下几个点来理解equals和hashCode方法:
      1、equals的作用及与==的区别。
      2、hashcode的作用及与equals的关系。

    1、equals的作用及与==的区别。

    equals被用来判断两个对象是否相等。
    equals通常用来比较两个对象的内容是否相等,==用来比较两个对象的地址是否相等。
    equals方法默认等同于“==”
    Object类中的equals方法定义为判断两个对象的地址是否相等(可以理解成是否是同一个对象),地址相等则认为是对象相等。这也就意味着,我们新建的所有类如果没有复写equals方法,那么判断两个对象是否相等时就等同于“==”,也就是两个对象的地址是否相等。
    Object类中equals的方法实现如下:

    public boolean equals(Object obj) {
            return (this == obj);
        }
    

    但在我们的实际开发中,通常会认为两个对象的内容相等时,则两个对象相等,equals返回true。对象内容不同,则返回false。

    • 所以可以总结为两种情况
      1、类未复写equals方法,则使用equals方法比较两个对象时,相当于==比较,即两个对象的地址是否相等。地址相等,返回true,地址不相等,返回false。
      2、类复写equals方法,比较两个对象时,则走复写之后的判断方式。通常,我们会将equals复写成:当两个对象内容相同时,则equals返回true,内容不同时,返回false。
      举个例子:
    public class EqualTest {
    public static void main(String[] args) {
    	Person p1 = new Person(10,"张三");
    	Person p2 = new Person(10,"张三");
    	System.out.println(p1.equals(p2));
    	}
    }
    class Person{
    	int age;
    	String name;
    	public Person(int age, String name) {
    		super();
    		this.age = age;
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    }
    

    Person未复写equals方法,则默认使用了Object中的equals,即为两个对象(p1和p2)的内存地址判断,p1和p2很明显内存地址不同,所以输出结果很明显为false。
    如果我们复写equals方法呢?我们认为名字和年龄一样的就是同一个人,那么p1和p2都表示10岁的张三,这两个对象应该是相等的。复写的equals方法如下:

    @Override
    public boolean equals(Object obj) {
    	if (this == obj)
    		return true;
    	if (obj == null)
    		return false;
    	if (getClass() != obj.getClass())
    		return false;
    	Person other = (Person) obj;
    	if (age != other.age)
    		return false;
    	if (name == null) {
    	if (other.name != null)
    		return false;
    	} else if (!name.equals(other.name))
    		return false;
    	return true;
    }
    

    同样的,执行上述用例,得到的结果是true。
    BTW:如果equals方法返回true,那么==是否也是true?
    不一定是true。equals返回true有两种可能,一种是两个对象地址相同,一种是两个对象内容相同。当内容相同时,地址可能不同,所以==比较的结果可能为false。
    我们把main方法加上对==的判断,如下:

    
    public static void main(String[] args) {
    	Person p1 = new Person(10,"张三");
    	Person p2 = new Person(10,"张三");
    	System.out.println(p1.equals(p2));
    	System.out.println(p1 == p2);
    }
    

    输出结果很明显 p1==p2的结果是false。

    补充Java中对Equals的要求:

    
    1. 对称性:如果x.equals(y)返回是"true",那么y.equals(x)也应该返回是"true"。
    2. 反射性:x.equals(x)必须返回是"true"。
    3. 类推性:如果x.equals(y)返回是"true",而且y.equals(z)返回是"true",那么z.equals(x)也应该返回是"true"。
    4. 一致性:如果x.equals(y)返回是"true",只要x和y内容一直不变,不管你重复x.equals(y)多少次,返回都是"true"。
    5. 非空性,x.equals(null),永远返回是"false";x.equals(和x不同类型的对象)永远返回是"false"。
    

    2、hashCode的作用及与equals的关系。

    hashCode的作用是用来获取哈希码,也可以称作散列码。实际返回值为一个int型数据。用于确定对象在哈希表中的位置。
    Object中有hashcode方法,也就意味着所有的类都有hashCode方法。
    但是,hashcode只有在创建某个类的散列表的时候才有用,需要根据hashcode值确认对象在散列表中的位置,但在其他情况下没用。
    java中本质上是散列表的类常见的有HashMap,HashSet,HashTable
    所以,如果一个对象一定不会在散列表中使用,那么是没有必要复写hashCode方法的。但一般情况下我们还是会复写hashCode方法,因为谁能保证这个对象不会出现再hashMap等中呢?
    举个例子:
    两个对象equals相等的时候,hashcode并不一定相等。

    public class EqualTest {
    	public static void main(String[] args) {
    		Person p1 = new Person(10, "张三");
    		Person p2 = new Person(10, "张三");
    		System.out.println(
    		"p1.equals(p2)=" + p1.equals(p2) + ", p1.hashcode=" + p1.hashCode() + ", p2.hashcode=" + p2.hashCode());
    	}
    }
    class Person {
    	int age;
    	String name;
    	public Person(int age, String name) {
    		super();
    		this.age = age;
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Person other = (Person) obj;
    		if (age != other.age)
    			return false;
    		if (name == null) {
    		if (other.name != null)
    			return false;
    		} else if (!name.equals(other.name))
    			return false;
    		return true;
    	}
    }
    

    Person没有复写hashCode方法,使用Object默认的hashCode实现,输出结果如下:

    
    p1.equals(p2)=true, p1.hashcode=246688959, p2.hashcode=1457895203
    

    从结果可以看出,equals虽然相同,但是p1和p2的hashcode并不相同。

    如果Person用于散列表的类中呢,这里用HashSet来做测试。

    public class EqualTest {
    	public static void main(String[] args) {
    		Person p1 = new Person(10, "张三");
    		Person p2 = new Person(10, "张三");
    		System.out.println(
    		"p1.equals(p2)=" + p1.equals(p2) + ", p1.hashcode=" + p1.hashCode() + ", p2.hashcode=" + p2.hashCode());
    		HashSet<Person> set = new HashSet<Person>();
    		set.add(p1);
    		set.add(p2);
    		System.out.println(set);
    	}
    }
    class Person {
    	int age;
    	String name;
    	public Person(int age, String name) {
    		super();
    		this.age = age;
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Person other = (Person) obj;
    		if (age != other.age)
    			return false;
    		if (name == null) {
    		if (other.name != null)
    			return false;
    		} else if (!name.equals(other.name))
    			return false;
    		return true;
    	}
    	@Override
    	public String toString() {
    		return "Person [age=" + age + ", name=" + name + "]";
    	}
    }
    

    输出结果

    p1.equals(p2)=true, p1.hashcode=246688959, p2.hashcode=1457895203
    [Person [age=10, name=张三], Person [age=10, name=张三]]
    

    p1和p2的equals相同,我们认为是两个对象相等,但是这两个对象竟然同时出现再hashSet中,hashSet中是不会出现两个相同的元素的。
    那问题在哪里?

    • hashset在添加一个元素的时候,会做如下判断:
      1、如果添加元素的hashcode相等并且 对象equals为true或对象== 时,则认为是同一个元素,不添加到新元素中。
      2、如果不符合上述条件,则认为是一个新元素,添加到set中。
      所以,虽然p1和p2equals比较时相等,但是hashcode并不一样,所以在往set中添加的时候认为是两个不同的元素,所以才会出现了p1和p2同时在set中的情况。

    过程:
    当你把对象加入HashSet时,HashSet会先计算对象的hashcode值来判断对象加入的位置,同时也会与加入的对象的hashcode值做比较,如果没有相符的hashcode,Hashset会假设对象没有重复出现。但是如果发现有相同的hashcode值的对象,这是会调用equals()方法来检测hashcode 相等的对象是否真的相同,如果两者相同,Hashset就不会让加入操作成功。

    我们改进下,复写一下hashcode方法,如下:

    
    class Person {
    	int age;
    	String name;
    	public Person(int age, String name) {
    		super();
    		this.age = age;
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + age;
    		result = prime * result + ((name == null) ? 0 : name.hashCode());
    		return result;
    	}
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Person other = (Person) obj;
    		if (age != other.age)
    			return false;
    		if (name == null) {
    		if (other.name != null)
    			return false;
    		} else if (!name.equals(other.name))
    			return false;
    		return true;
    	}
    	@Override
    	public String toString() {
    		return "Person [age=" + age + ", name=" + name + "]";
    	}
    }
    

    重新执行结果:

    p1.equals(p2)=true, p1.hashcode=776160, p2.hashcode=776160
    [Person [age=10, name=张三]]
    

    于是看到set中仅有一个Person值了。

    • 补充几点:
      1、新建一个类,尤其是业务相关的对象类的时候,最好复写equals方法。
      2、复写equals方法时,同时记着要复写hashCode方法,谁能保证说这个对象一定不会出现在hashMap中呢?如果你用的是eclipse的自动代码生成,你会发现eclipse中复写equals和hashCode是在一起的。

    • 引申出几个经常在面试中问到的问题:
      1、两个对象,如果a.equals(b)==true,那么a和b是否相等?
      相等,但地址不一定相等。
      2、两个对象,如果hashcode一样,那么两个对象是否相等?
      不一定相等,判断两个对象是否相等,需要判断equals是否为true。

    • hashcode()和equals()的相关规定

    1. 如果两个对象相等,则hashcode一定也是相同的
    2. 两个对象相等,对两个equals和hashcode()方法返回true
    3. 两个对象相同的hashcode值,他们也不一定是相等的
    4. 综上:equals方法被覆盖过,则hashcode方法也必须被覆盖
    5. hsashcode()的默认行为是堆上的对象产生独特值。如果没有重写hashCode(),则改class两个对象无论如何都不会相等的(即使这两个对象指向相同的数据)
    展开全文
  • 那么,对于基本类型我们该如何判断值是否相等呢? 1、我们先来看个个示例: 示例1:基本类型的比较 //基本类型比较 public static void test1() { int a = 21; int b = 21; if (a == b) { System.out....

    我们都知道,在java中“==”运算符比较的是对象在堆内存上的地址,如果要比较对象的值需要使用equals()方法。那么,对于基本类型我们该如何判断值是否相等呢?

    1、我们先来看几个个示例:

    示例1:基本类型的比较

    //基本类型比较
    public static void test1() {
    	int a = 21;
    	int b = 21;
    	if (a == b) {
    		System.out.println("a == b yes");
    	} else {
    		System.out.println("a == b no");
    	}
    	
    	int c = 1270;
    	int d = 1270;
    	if (c == d) {
    		System.out.println("c == d yes");
    	} else {
    		System.out.println("c == d no");
    	}
    }

    输出:

    a == b yes
    c == d yes

    示例2:包装类型之间的比较 

    public static void test2() {
    	Integer a = 21;
    	Integer b = 21;
    	if (a == b) {
    		System.out.println("a == b yes");
    	} else {
    		System.out.println("a == b no");
    	}
    	if (a.equals(b)) {
    		System.out.println("a.equals(b) yes");
    	}
    	if (a.intValue() == b.intValue()) {
    		System.out.println("a.intValue() == b.intValue() yes");
    	}
    	
    	Integer c = 1270;
    	Integer d = 1270;
    	if (c == d) {
    		System.out.println("c == d yes");
    	} else {
    		System.out.println("c == d no");
    	}
    	if (c.equals(d)) {
    		System.out.println("c.equals(d) yes");
    	}
    	if (c.intValue() == d.intValue()) {
    		System.out.println("c.intValue() == d.intValue() yes");
    	}
    }

    输出:

    a == b yes
    a.equals(b) yes
    a.intValue() == b.intValue() yes
    c == d no
    c.equals(d) yes
    c.intValue() == d.intValue() yes

    示例3:基本类型和包装类型的比较

    public static void test3() {
    	Integer a = 21;
    	int b = 21;
    	if (a == b) {//自动拆箱
    		System.out.println("a == b yes");
    	} else {
    		System.out.println("a == b no");
    	}
    	if (a.equals(b)) {//自动装箱
    		System.out.println("a.equals(b) yes");
    	}
    	if (a.intValue() == b) {
    		System.out.println("a.intValue() == b.intValue() yes");
    	}
    	
    	Integer c = 1270;
    	int d = 1270;
    	if (c == d) {
    		System.out.println("c == d yes");
    	} else {
    		System.out.println("c == d no");
    	}
    	if (c.equals(d)) {
    		System.out.println("c.equals(d) yes");
    	}
    	if (c.intValue() == d) {
    		System.out.println("c.intValue() == d.intValue() yes");
    	}
    }

    输出:

    a == b yes
    a.equals(b) yes
    a.intValue() == b.intValue() yes
    c == d yes
    c.equals(d) yes
    c.intValue() == d.intValue() yes

    2、分析:

    1)对于基本类型,由于不是对象,所以不存在地址,更没有equals等方法,故此只有使用“==”来进行值比较。

    2)包装类:

    Integer a = n; 这句话背后编译器实际上调用了valueOf()方法进行了自动装箱,我们看该代码:

    public static Integer valueOf(int i) {
    	if (i >= IntegerCache.low && i <= IntegerCache.high)
    		return IntegerCache.cache[i + (-IntegerCache.low)];
    	return new Integer(i);
    }

    这里做了一个判断,接下来看一下IntegerCache源码:

    private static class IntegerCache {
    	static final int low = -128;
    	static final int high;
    	static final Integer cache[];
    
    	static {
    		// high value may be configured by property
    		int h = 127;
    		String integerCacheHighPropValue =
    			sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
    		if (integerCacheHighPropValue != null) {
    			try {
    				int i = parseInt(integerCacheHighPropValue);
    				i = Math.max(i, 127);
    				// Maximum array size is Integer.MAX_VALUE
    				h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
    			} catch( NumberFormatException nfe) {
    				// If the property cannot be parsed into an int, ignore it.
    			}
    		}
    		high = h;
    
    		cache = new Integer[(high - low) + 1];
    		int j = low;
    		for(int k = 0; k < cache.length; k++)
    			cache[k] = new Integer(j++);
    
    		// range [-128, 127] must be interned (JLS7 5.1.7)
    		assert IntegerCache.high >= 127;
    	}
    
    	private IntegerCache() {}
    }

    到这里我们明白了,对于[-128,127]之间的数,jdk会将包装类对象做一个cache,所以我们可以使用”==“来比较对象的地址(地址都相同了,值肯定相同),超出了这个范围,就会new一个新的对象,所以在用”==“比较,肯定是不同的对象地址,返回false。

    3)基本类型和包装类型之间的比较:

    我们都知道,java对基本类型和包装类之间是可以通过自动装箱、拆箱转换的,所以,我们通过“==”运算符 或 equals方法都可以进行比较。

    • 自动装箱:编译器调用valueOf将基本类型值转换成包装类型;
    • 自动拆箱:编译器通过调用类似intValue(),doubleValue()这类的方法将包装转换成基本原始类型值。

    在示例3中:if (a == b) 实际上是通过了自动拆箱转换成了if (a.intValue() == b) ,进而转换成了基本类型的比较;对于if (a.equals(b))  实际上是通过自动装箱转换成了if (a.equals(Integer.valueOf(b))) ,进而转换成了包装类型的equals比较。

     

    3、结论:

    1. 由于常量池中的缓存,基本类型的包装类值在[-128,127] 期间,可以用 “==”进行值比较(Double、Float是没有缓存的),不在该范围内的需要使用equals进行值比较;(对于包装类,无论何时强烈推荐都使用equals进行值比较
    2. 基本类型的包装类,也可以手动拆箱转成基本类型(例如:intValue()),再使用”==“进行值比较;
    3. 基本类型和基本类型的包装类之间的比较,可以直接使用”==“运算符进行值比较(jdk使用了自动拆箱),也可以使用equals方法进行值比较(jdk编译器使用了自动装箱);
    4. 对于基本类型,使用”==“运算符进行值比较;

     

    展开全文
  • 前言: 本文不是来讲述IP地址的发展、划分及计算,因为这文章太多太多了,网上随便一搜就是一大堆,而且讲的都很不错。这里只想说说平时比较容易混淆的个概念,和IP地址...◆如何判断2个IP是否处在同一网段...
  • T C P拦截这一部分,最后给出个使用该特性的 示例。之后,介绍 N AT的整体概念,包括 N AT的引入、 N AT特性以及如何将其用于网络中。 最后将讨论有关N AT的配置和调试命令,并介绍许多详细的示例。 8.1 TCP...
  • 课程内容:今天我们要实现智能加血,什么是智能加血呢,我们要自动判断背包里哪个物品是药,那么如何判断呢,首先我们尝试了类型的判断发现补蓝和补血的类型名字一样,那么排除掉,那样的话我们只好用名字匹配了,幸好这个...
  • 137_指针17_何谓变量的地址 一个指针变量到底占个字节【难点】 136_指针16_指针变量的运算 135_指针15_复习上节课知识 134_指针14_确定一个一维数组需要2个参数及其原因_下 134_指针14_确定一个一维数组需要2个...
  • 19地下水按含水层空隙性质分哪几类? 答:1)孔隙水 指赋存于第四纪疏松沉积物和部分前第四纪胶结较差的松散岩层孔隙中的重力水 2)裂隙水 指埋藏于岩石的风化裂隙、成岩裂隙和构造裂隙中的地下水。 3)岩溶水 指...
  • <div><p>使用xray过程中的点疑问,烦请解答一下,感谢。 1. 敏感文件扫描模块能否支持自行删减内置字典?(不是取并集) 个人觉得目前内置字典里面有很多没必要扫描的文件,...
  •  对于SSDT,不知道的同学请自己百度,判断出SSDT被HOOK之后,如何恢复成原始服务地址?主要方法有两个,简单来说,一个Ring0,一个Ring3的方法(可能分类不够准确),我今天除了介绍方法之外,主要还是讲讲里面的原理吧,原理...
  •  实例091 使用正则表达式验证IP地址 106 实例092 使用正则表达式验证URL 107 第4章 数组和集合的使用 109 4.1 数组的基本操作 110  实例093 获取多维数组的行数与列数 110  实例094 按指定条件在数组中...
  • Tomcat问题总结1

    2020-05-05 17:12:20
    3.Web资源可以分成哪几类?4.Tomcat当前企业常用的版本是`7.*、8*`5.Tomcat的目录介绍6.如何启动 Tomcat 服务器7.本地登录tomcat主页,可以有几种输入地址?8.如何判断Tomcat启动成功?9.如果启动tomcat闪退,可能的...
  • 怎样判断获得的视图指针是哪一个 如何取得MDI应用程序中每个视图的指针 第6章 消息系统、钩子函数及DLL 如何自定义消息 应用程序传送的消息有哪些以及有什么区别 如何个菜单项的消息处理函数放入一个函数中 ...
  • 银联接入若干问题

    2017-12-14 20:26:40
    1.如何判断 交易状态查询交易 是否操作成功 ?  ①交易状态查询交易是不记库的,平台捞取不到交易数据,所以就是一个/在那。这个交易接口的话,只要商户这边能通过这个接口查询到被查询交易的状态就可以。 ...
  • ASP200问.EXE

    2010-05-20 13:25:08
    19.如何判断字符串是否以指定字符串开头或结尾 20.如何判断字符是否是英文字符 21.如何检测字符串出现的次数 22.如何过滤字符串中的HTML代码 23.如何截取字符串 24.如何实现字符串和数组的转换 25.如何实现字符大小...
  • Tips:判断是否是系统软件和应用软件首先需要从是否管理硬件的角度出发,大致分为以下几类 冯·诺依曼计算机的特点?(6条) 计算机由五大部件组成 指令和数据以同等地位存于存储器,可按地址寻访(思考如何存储器...
  • 知识总结(四)

    2020-08-12 17:03:10
    1.如何停止一个线程 标志位,stop() 基本不用了,interrupt 2.创建线程有种方式。... }:用以判断变量参数与当前实例是否相等,JDK默认实现是基于对象内存地址是否相同,如果两个对象内存地址相同
  • ECSHOP设置及开发技巧汇总

    热门讨论 2012-11-22 09:29:29
    2.14 如何将ECSHOP中的相对地址改为绝对地址 43 2.15 goods.php重命名 44 2.16 在Ecshop商品详情页显示当前会员等级价格 45 2.17 修改广告链接地址affiche.php为普通链接 46 2.18 如何让ecshop首页商品显示购买过的...
  • C#编程经验技巧宝典

    热门讨论 2008-06-01 08:59:33
    113 <br>5.6 其他应用技巧 114 <br>0189 如何判断年份是否为闰年 114 <br>0190 如何根据年份判断十二生肖 114 <br>0191 如何根据IP地址获取本机域名 115 <br>0192 如何获取“我的文档”系统...
  • delphi 开发经验技巧宝典源码

    热门讨论 2010-08-12 16:47:23
    0040 如何实现的转形 26 0041 如何实现数据加密与解密算法 27 0042 如何继承父类的方法 27 0043 如何实现函数重载 28 0044 中多态的应用 28 0045 将函数作为参数进行调用 30 2.3 参数与指针 30 ...
  • 苏宁网申笔试题

    千次阅读 2020-08-26 20:51:26
    Java的集合有哪些 HashMap的线程安全问题 线程之间如何进行通信 线程池 锁的命令 异常类型有哪种 String s1 = “I”和String s2 = new String(“I”)在equals方法和HashCode方法判断是否相等 Java...
  • 0040 如何实现的转形 26 0041 如何实现数据加密与解密算法 27 0042 如何继承父类的方法 27 0043 如何实现函数重载 28 0044 中多态的应用 28 0045 将函数作为参数进行调用 30 2.3 参数与指针 30 ...
  • 0040 如何实现的转形 26 0041 如何实现数据加密与解密算法 27 0042 如何继承父类的方法 27 0043 如何实现函数重载 28 0044 中多态的应用 28 0045 将函数作为参数进行调用 30 2.3 参数与指针 30 ...
  • 0040 如何实现的转形 26 0041 如何实现数据加密与解密算法 27 0042 如何继承父类的方法 27 0043 如何实现函数重载 28 0044 中多态的应用 28 0045 将函数作为参数进行调用 30 2.3 参数与指针 30 ...
  • 0040 如何实现的转形 26 0041 如何实现数据加密与解密算法 27 0042 如何继承父类的方法 27 0043 如何实现函数重载 28 0044 中多态的应用 28 0045 将函数作为参数进行调用 30 2.3 参数与指针 30 ...
  • 0040 如何实现的转形 26 0041 如何实现数据加密与解密算法 27 0042 如何继承父类的方法 27 0043 如何实现函数重载 28 0044 中多态的应用 28 0045 将函数作为参数进行调用 30 2.3 参数与指针 30 ...
  • VC++常用功能实例

    2010-01-25 23:28:46
    如何在程序判断出debug状态◆ 27 ◆当对话框中有一个滚动条是,当滚动滚动条时的消息控制函数◆ 27 ◆将一个CWnd指针转换成一个控件ID(整数)注意用GetDlgItem()函数是从一个控件ID转换成一个CWnd的指针◆ 28 ◆...
  • 如何在程序判断出debug状态◆ 27 ◆当对话框中有一个滚动条是,当滚动滚动条时的消息控制函数◆ 27 ◆将一个CWnd指针转换成一个控件ID(整数)注意用GetDlgItem()函数是从一个控件ID转换成一个CWnd的指针◆ 28 ◆...
  • 3.5.3 给40亿个不重复的unsigned int的整数,没排过序的,然后再给个数,如何快速判断个数是否在那40亿个数当中? 3.5.4 在一个文件中有10G个整数,乱序排列,要求找出中位数。内存限制为2G。 3.5.5 时分秒针...

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 234
精华内容 93
关键字:

如何判断几类地址