老友wan
老友wan

Java代码通过经纬度计算省份。

Java代码通过经纬度计算省份。_第1张图片

Java代码通过经纬度计算省份。_第2张图片Java代码通过经纬度计算省份。_第3张图片

 直接上代码，需要市区县可自己解析

String areaName = addressUtil.getPosition(longitude, latitude);
package com.skyable.device.utils.velicle;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Synchronized;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author Administrator
 */
@Component
public class AddressUtil {
    @Autowired
    private JsonUtil jsonUtil;

    private static final List> LIST = new ArrayList<>();
    private static final Map> MAP = new HashMap<>();

    @Synchronized
    public String getPosition(Double longitude, Double latitude) {
        String areaName = "中国";
        Map resultMap = new HashMap<>();
        resultMap.put("code", 500);
        resultMap.put("message", "失败");
        if (longitude == null || latitude == null) {
            return areaName;
        }
        if (LIST.isEmpty()) {
            LIST.addAll(jsonUtil.readJson());
        }
        if (MAP.isEmpty()) {
            for (Map jsonMap : LIST) {
                MAP.put(Integer.valueOf(jsonMap.get("id").toString()), jsonMap);
            }
        }

        double minDistance = 0.0D;
        Map shopAreaMap = new HashMap<>();
        boolean first = true;
        for (Map areaMap : LIST) {
            String level = areaMap.get("level").toString();
            String lng = areaMap.get("lng").toString().replace("\"", "");
            String lat = areaMap.get("lat").toString().replace("\"", "");

            if (!("1".equals(level) || "2".equals(level)) && (!"null".equals(lng)) && (!"null".equals(lat))) {
                double distance = CoordTransform.getDistance(latitude, longitude, Double.parseDouble(lat), Double.parseDouble(lng));
                if (minDistance == 0.0D && first) {
                    minDistance = distance;
                    shopAreaMap = areaMap;
                    first = false;
                } else if (distance < minDistance) {
                    minDistance = distance;
                    shopAreaMap = areaMap;
                }
            }
        }
        if (!shopAreaMap.isEmpty() && shopAreaMap.get("level") != null) {
            int level = Integer.parseInt(shopAreaMap.get("level").toString());

            if (level == 4 || level == 3) {
                Map parentMap = MAP.get(Integer.valueOf(shopAreaMap.get("parentid").toString()));
                if (parentMap != null) {
                    if (level == 4) {
                        Map cityMap = MAP.get(Integer.valueOf(parentMap.get("parentid").toString()));
                        if (cityMap != null) {
                            shopAreaMap = cityMap;
                        }
                        shopAreaMap.put("county", parentMap);
                    } else {
                        shopAreaMap.put("county", shopAreaMap);
                    }
                    shopAreaMap = parentMap;
                }
            }
            shopAreaMap.put("shortname", MAP.get(Integer.valueOf(shopAreaMap.get("parentid").toString())).get("areaname").toString());
        }
        resultMap.put("data", shopAreaMap);
        Object parentId = shopAreaMap.get("parentid");
        for (Map record : LIST) {
            Object id = record.get("id");
            if (parentId.equals(id)) {
                parentId = record.get("parentid");
            }
        }
        for (Map map : LIST) {
            if (map.get("id").equals(parentId)) {
                areaName = map.get("areaname").toString().replaceAll("\"", "");
            }
        }
        return areaName;
    }
}
package com.skyable.device.utils.velicle;

/**
 * @author Administrator
 */
public class CoordTransform {
    private static final double X_PI = 52.359877559829883;
    private static final double PI = 3.141592653589793;
    private static final double A = 6378245.0;
    private static final double EE = 0.006693421622965943;
    public static double getDistance(double x1, double y1, double x2, double y2) {
        double x = (x1 - x2) * PI * A *
                Math.cos((y1 + y2) / 2.0 * PI / 180.0) / 180.0;
        double y = (y2 - y1) * PI * A / 180.0;
        return Math.sqrt(x * x + y * y);
    }
}

package com.skyable.device.utils.velicle;

public class IPEntry {
    public String beginIp;
    public String endIp;
    public String country;
    public String area;

    public IPEntry() {
        this.beginIp = (this.endIp = this.country = this.area = "");
    }

    @Override
    public String toString() {
        return this.area + "  " + this.country + "IP范围:" + this.beginIp + "-" +
                this.endIp;
    }
}

package com.skyable.device.utils.velicle;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteOrder;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.util.*;

public class IPSeeker {
    private static final String IP_FILE = PropertiesUtil.getProperty("IP_DATA_URL");
    private static final int IP_RECORD_LENGTH = 7;
    private static final byte AREA_FOLLOWED = 1;
    private static final byte NO_AREA = 2;
    private static Hashtable ipCache;
    private static RandomAccessFile ipFile;
    private static MappedByteBuffer mbb;
    private static IPSeeker instance = new IPSeeker();
    private static long ipBegin;
    private static long ipEnd;
    private static IPLocation loc;
    private static byte[] buf;
    private static byte[] b4;
    private static byte[] b3;

    private IPSeeker() {
        ipCache = new Hashtable();
        loc = new IPLocation();
        buf = new byte[100];
        b4 = new byte[4];
        b3 = new byte[3];
        try {
            ipFile = new RandomAccessFile(IP_FILE, "r");
        } catch (FileNotFoundException e) {
            System.out.println(IP_FILE);
            System.out.println("IP地址信息文件没有找到，IP显示功能将无法使用");
            ipFile = null;
        }

        if (ipFile != null) {
            try {
                ipBegin = readLong4(0L);
                ipEnd = readLong4(4L);
                if ((ipBegin == -1L) || (ipEnd == -1L)) {
                    ipFile.close();
                    ipFile = null;
                }
            } catch (IOException e) {
                System.out.println("IP地址信息文件格式有错误，IP显示功能将无法使用");
                ipFile = null;
            }
        }
    }

    public static IPSeeker getInstance() {
        return instance;
    }

    public List getIPEntriesDebug(String s) {
        List ret = new ArrayList();
        long endOffset = ipEnd + 4L;
        for (long offset = ipBegin + 4L; offset <= endOffset; offset += 7L) {
            long temp = readLong3(offset);

            if (temp != -1L) {
                IPLocation loc = getIPLocation(temp);

                if ((loc.country.indexOf(s) != -1) || (loc.area.indexOf(s) != -1)) {
                    IPEntry entry = new IPEntry();
                    entry.country = loc.country;
                    entry.area = loc.area;

                    readIP(offset - 4L, b4);
                    entry.beginIp = Utils.getIpStringFromBytes(b4);

                    readIP(temp, b4);
                    entry.endIp = Utils.getIpStringFromBytes(b4);

                    ret.add(entry);
                }
            }
        }
        return ret;
    }

    public List getIPEntries(String s) {
        List ret = new ArrayList();
        try {
            if (mbb == null) {
                FileChannel fc = ipFile.getChannel();
                mbb = fc.map(FileChannel.MapMode.READ_ONLY, 0L, ipFile.length());
                mbb.order(ByteOrder.LITTLE_ENDIAN);
            }

            int endOffset = (int) ipEnd;
            for (int offset = (int) ipBegin + 4; offset <= endOffset; offset += 7) {
                int temp = readInt3(offset);
                if (temp != -1) {
                    IPLocation loc = getIPLocation(temp);

                    if ((loc.country.indexOf(s) != -1) ||
                            (loc.area.indexOf(s) != -1)) {
                        IPEntry entry = new IPEntry();
                        entry.country = loc.country;
                        entry.area = loc.area;

                        readIP(offset - 4, b4);
                        entry.beginIp = Utils.getIpStringFromBytes(b4);

                        readIP(temp, b4);
                        entry.endIp = Utils.getIpStringFromBytes(b4);

                        ret.add(entry);
                    }
                }
            }
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
        return ret;
    }

    private int readInt3(int offset) {
        mbb.position(offset);
        return mbb.getInt() & 0xFFFFFF;
    }

    private int readInt3() {
        return mbb.getInt() & 0xFFFFFF;
    }

    public static String getCountry(byte[] ip) {
        if (ipFile == null) {
            return "错误的IP数据库文件";
        }
        String ipStr = Utils.getIpStringFromBytes(ip);

        if (ipCache.containsKey(ipStr)) {
            IPLocation loc = (IPLocation) ipCache.get(ipStr);
            return loc.country;
        }
        IPLocation loc = getIPLocation(ip);
        ipCache.put(ipStr, loc.getCopy());
        return loc.country;
    }

    public static String getCountry(String ip) {
        return getCountry(Utils.getIpByteArrayFromString(ip));
    }

    public String getArea(byte[] ip) {
        if (ipFile == null) {
            return "错误的IP数据库文件";
        }
        String ipStr = Utils.getIpStringFromBytes(ip);

        if (ipCache.containsKey(ipStr)) {
            IPLocation loc = (IPLocation) ipCache.get(ipStr);
            return loc.area;
        }
        IPLocation loc = getIPLocation(ip);
        ipCache.put(ipStr, loc.getCopy());
        return loc.area;
    }

    public String getArea(String ip) {
        return getArea(Utils.getIpByteArrayFromString(ip));
    }

    private static IPLocation getIPLocation(byte[] ip) {
        IPLocation info = null;
        long offset = locateIP(ip);
        if (offset != -1L) {
            info = getIPLocation(offset);
        }
        if (info == null) {
            info.country = "未知国家";
            info.area = "未知地区";
        }
        return info;
    }

    private long readLong4(long offset) {
        long ret = 0L;
        try {
            ipFile.seek(offset);
            ret |= ipFile.readByte() & 0xFF;
            ret |= ipFile.readByte() << 8 & 0xFF00;
            ret |= ipFile.readByte() << 16 & 0xFF0000;
            return ret | ipFile.readByte() << 24 & 0xFF000000;
        } catch (IOException e) {
        }
        return -1L;
    }

    private static long readLong3(long offset) {
        long ret = 0L;
        try {
            ipFile.seek(offset);
            ipFile.readFully(b3);
            ret |= b3[0] & 0xFF;
            ret |= b3[1] << 8 & 0xFF00;
            return ret | b3[2] << 16 & 0xFF0000;
        } catch (IOException e) {
        }
        return -1L;
    }

    private static long readLong3() {
        long ret = 0L;
        try {
            ipFile.readFully(b3);
            ret |= b3[0] & 0xFF;
            ret |= b3[1] << 8 & 0xFF00;
            return ret | b3[2] << 16 & 0xFF0000;
        } catch (IOException e) {
        }
        return -1L;
    }

    private static void readIP(long offset, byte[] ip) {
        try {
            ipFile.seek(offset);
            ipFile.readFully(ip);
            byte temp = ip[0];
            ip[0] = ip[3];
            ip[3] = temp;
            temp = ip[1];
            ip[1] = ip[2];
            ip[2] = temp;
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    private void readIP(int offset, byte[] ip) {
        mbb.position(offset);
        mbb.get(ip);
        byte temp = ip[0];
        ip[0] = ip[3];
        ip[3] = temp;
        temp = ip[1];
        ip[1] = ip[2];
        ip[2] = temp;
    }

    private static int compareIP(byte[] ip, byte[] beginIp) {
        for (int i = 0; i < 4; i++) {
            int r = compareByte(ip[i], beginIp[i]);
            if (r != 0) {
                return r;
            }
        }
        return 0;
    }

    private static int compareByte(byte b1, byte b2) {
        if ((b1 & 0xFF) > (b2 & 0xFF)) {
            return 1;
        }
        if ((b1 ^ b2) == 0) {
            return 0;
        }
        return -1;
    }

    private static long locateIP(byte[] ip) {
        long m = 0L;

        readIP(ipBegin, b4);
        int r = compareIP(ip, b4);
        if (r == 0) {
            return ipBegin;
        }
        if (r < 0) {
            return -1L;
        }
        long i = ipBegin;
        for (long j = ipEnd; i < j; ) {
            m = getMiddleOffset(i, j);
            readIP(m, b4);
            r = compareIP(ip, b4);

            if (r > 0) {
                i = m;
            } else if (r < 0) {
                if (m == j) {
                    j -= 7L;
                    m = j;
                } else {
                    j = m;
                }
            } else {
                return readLong3(m + 4L);
            }

        }

        m = readLong3(m + 4L);
        readIP(m, b4);
        r = compareIP(ip, b4);
        if (r <= 0) {
            return m;
        }
        return -1L;
    }

    private static long getMiddleOffset(long begin, long end) {
        long records = (end - begin) / 7L;
        records >>= 1;
        if (records == 0L) {
            records = 1L;
        }
        return begin + records * 7L;
    }

    private static IPLocation getIPLocation(long offset) {
        try {
            ipFile.seek(offset + 4L);

            byte b = ipFile.readByte();
            if (b == 1) {
                long countryOffset = readLong3();

                ipFile.seek(countryOffset);

                b = ipFile.readByte();
                if (b == 2) {
                    loc.country = readString(readLong3());
                    ipFile.seek(countryOffset + 4L);
                } else {
                    loc.country = readString(countryOffset);
                }
                loc.area = readArea(ipFile.getFilePointer());
            } else if (b == 2) {
                loc.country = readString(readLong3());
                loc.area = readArea(offset + 8L);
            } else {
                loc.country = readString(ipFile.getFilePointer() - 1L);
                loc.area = readArea(ipFile.getFilePointer());
            }
            return loc;
        } catch (IOException e) {
        }
        return null;
    }

    private IPLocation getIPLocation(int offset) {
        mbb.position(offset + 4);

        byte b = mbb.get();
        if (b == 1) {
            int countryOffset = readInt3();

            mbb.position(countryOffset);

            b = mbb.get();
            if (b == 2) {
                loc.country = readString(readInt3());
                mbb.position(countryOffset + 4);
            } else {
                loc.country = readString(countryOffset);
            }
            loc.area = readArea(mbb.position());
        } else if (b == 2) {
            loc.country = readString(readInt3());
            loc.area = readArea(offset + 8);
        } else {
            loc.country = readString(mbb.position() - 1);
            loc.area = readArea(mbb.position());
        }
        return loc;
    }

    private static String readArea(long offset)
            throws IOException {
        ipFile.seek(offset);
        byte b = ipFile.readByte();
        if ((b == 1) || (b == 2)) {
            long areaOffset = readLong3(offset + 1L);
            if (areaOffset == 0L) {
                return "未知地区";
            }
            return readString(areaOffset);
        }
        return readString(offset);
    }

    private String readArea(int offset) {
        mbb.position(offset);
        byte b = mbb.get();
        if ((b == 1) || (b == 2)) {
            int areaOffset = readInt3();
            if (areaOffset == 0) {
                return "未知地区";
            }
            return readString(areaOffset);
        }
        return readString(offset);
    }

    private static String readString(long offset) {
        try {
            ipFile.seek(offset);

            int i = 0;
            for (buf[i] = ipFile.readByte(); buf[i] != 0; ) {
                buf[(++i)] = ipFile
                        .readByte();
            }

            if (i != 0) {
                return Utils.convertBytesToString(buf, 0, i, "GBK");
            }
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
        return "";
    }

    private String readString(int offset) {
        try {
            mbb.position(offset);

            int i = 0;
            for (buf[i] = mbb.get(); buf[i] != 0; buf[(++i)] = mbb.get()) {
                if (i != 0) {
                    return Utils.convertBytesToString(buf, 0, i, "GBK");
                }
            }
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
        return "";
    }

    public String getAddress(String ip) {
        String country = getCountry(ip).equals(" CZ88.NET") ? "null" :
                getCountry(ip);

        String area = getArea(ip).equals(" CZ88.NET") ? "null" : getArea(ip);
        String address = country + "|" + area;
        return address.trim();
    }

    public static String getAddressByCity(String ip) {
        String country = getCountry(ip).equals(" CZ88.NET") ? "null" :
                getCountry(ip);
        String address = country;
        return address.trim();
    }

    public static Map jqCity(String str) {
        String shortname = "";
        String areaname = "";
        Map map = new HashMap();
        boolean status = str.contains("省");
        if (status) {
            String[] splitstr = str.split("省");

            shortname = splitstr[0] + "省";
            areaname = splitstr[1];
            if (areaname.contains("市")) {
                areaname = areaname.split("市")[0] + "市";
            }
        }
        boolean xj = str.contains("新疆");
        if (xj) {
            String[] splitstr = str.split("新疆");
            for (String string : splitstr) {
                System.out.println(string);
            }
            shortname = "新疆";
            areaname = splitstr[1];
        }
        boolean xz = str.contains("西藏");
        if (xz) {
            String[] splitstr = str.split("西藏");
            for (String string : splitstr) {
                System.out.println(string);
            }
            shortname = "西藏";
            areaname = splitstr[1];
        }
        boolean nmg = str.contains("内蒙古");
        if (nmg) {
            String[] splitstr = str.split("内蒙古");
            for (String string : splitstr) {
                System.out.println(string);
            }
            shortname = "内蒙古";
            areaname = splitstr[1];
        }
        boolean nx = str.contains("宁夏");
        if (nx) {
            String[] splitstr = str.split("宁夏");
            for (String string : splitstr) {
                System.out.println(string);
            }
            shortname = "宁夏";
            areaname = splitstr[1];
        }
        boolean gx = str.contains("广西");
        if (gx) {
            String[] splitstr = str.split("广西");
            for (String string : splitstr) {
                System.out.println(string);
            }
            shortname = "广西";
            areaname = splitstr[1];
        }
        boolean bjs = str.contains("北京市");

        boolean tjs = str.contains("天津市");

        boolean shs = str.contains("上海市");

        boolean cqs = str.contains("重庆市");

        boolean xg = str.contains("香港");

        boolean am = str.contains("澳门");
        if ((am) || (xg) || (cqs) || (shs) || (tjs) || (bjs)) {
            System.out.println(str);
            shortname = str;
            areaname = str;
        }
        map.put("shortname", shortname);
        map.put("areaname", areaname);
        return map;
    }

    public static void main(String[] args) {
        IPSeeker is = new IPSeeker();

        System.out.println(is.getAddress("119.123.225.83"));

        System.out.println(is.getAddress("14.215.177.39"));

        System.out.println(is.getAddress("113.78.255.221"));

        System.out.println(is.getAddress("182.34.16.127"));

        System.out.println(is.getAddress("180.118.240.225"));

        System.out.println(is.getAddress("119.29.252.90"));

        System.out.println(is.getAddress("61.128.101.255"));

        System.out.println(is.getAddress("110.157.255.255"));

        System.out.println(is.getAddress("220.182.44.228"));

        System.out.println(is.getAddress("1.183.255.255"));

        System.out.println(is.getAddress("123.125.71.38"));

        System.out.println(is.getAddress("203.186.145.250"));

        System.out.println(is.getAddress("111.113.255.255"));

        System.out.println(is.getAddress("180.143.255.255"));
    }

    private class IPLocation {
        public String country;
        public String area;

        public IPLocation() {
            this.country = (this.area = "");
        }

        public IPLocation getCopy() {
            IPLocation ret = new IPLocation();
            ret.country = this.country;
            ret.area = this.area;
            return ret;
        }
    }
}

package com.skyable.device.utils.velicle;

import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

import java.util.*;

public class JsonToMap {
    public static JsonObject parseJson(String json) {
        JsonParser parser = new JsonParser();
        return parser.parse(json).getAsJsonObject();
    }

    public static Map toMap(String json) {
        return toMap(parseJson(json));
    }

    public static Map toMap(JsonObject json) {
        Map map = new HashMap<>();
        Set> entrySet = json.entrySet();
        for (Map.Entry entry : entrySet) {
            String key = entry.getKey();
            JsonElement value = entry.getValue();
            if (value.isJsonArray()) {
                map.put(key, toList(value.getAsJsonArray()));
            } else if (value.isJsonObject()) {
                map.put(key, toMap(value.getAsJsonObject()));
            } else {
                map.put(key, value);
            }
        }
        return map;
    }

    public static List toList(JsonArray json) {
        List list = new ArrayList<>();
        for (JsonElement element : json) {
            if (element.isJsonArray()) {
                list.add(toList(element.getAsJsonArray()));
            } else if (element.isJsonObject()) {
                list.add(toMap(element.getAsJsonObject()));
            } else {
                list.add(element);
            }
        }
        return list;
    }
}


package com.skyable.device.utils.velicle;

import com.google.gson.*;
import com.google.gson.stream.JsonReader;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Component
public class JsonUtil {
    @Value("${vehicle.jsonFile}")
    private String filePath;

    public List> readJson() {
        List> list = new ArrayList<>();

        if (filePath == null) {
            System.out.println("File path is null.");
            return list;
        }
        try (JsonReader reader = new JsonReader(new FileReader(filePath))) {
            Gson gson = new Gson();
            reader.beginObject(); // Start reading the root object
            while (reader.hasNext()) {
                String name = reader.nextName();
                if ("RECORDS".equals(name)) {
                    reader.beginArray(); // Start reading the array
                    while (reader.hasNext()) {
                        JsonObject subObject = gson.fromJson(reader, JsonObject.class);
                        list.add(subObject.entrySet().stream()
                                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
                    }
                    reader.endArray(); // End reading the array
                } else {
                    reader.skipValue(); // Skip other fields
                }
            }
            reader.endObject(); // End reading the root object
        } catch (IOException e) {
            e.printStackTrace();
        }
        return list;
    }

}



package com.skyable.device.utils.velicle;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Properties;

public class PropertiesUtil {
    private static final Logger logger = LoggerFactory.getLogger(PropertiesUtil.class);
    private static Properties props;

    static {
        // 更具描述性的文件名
        String fileName = "application.test";
        props = new Properties();
        try (InputStreamReader reader = new InputStreamReader(PropertiesUtil.class.getClassLoader().getResourceAsStream(fileName), "UTF-8")) {
            props.load(reader);
        } catch (IOException e) {
            logger.error("配置文件读取异常", e);
        }
    }

    public static String getProperty(String key) {
        String value = props.getProperty(key.trim());
        return value != null ? value.trim() : null;
    }

    public static String getProperty(String key, String defaultValue) {
        String value = props.getProperty(key.trim());
        return value != null ? value.trim() : defaultValue;
    }
}



package com.skyable.device.utils.velicle;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.UnsupportedEncodingException;
import java.util.StringTokenizer;

/**
 * @author Administrator
 */
public class Utils {
    private static final Logger logger = LoggerFactory.getLogger(Utils.class);

    public static byte[] getIpByteArrayFromString(String ip) {
        byte[] ret = new byte[4];
        StringTokenizer st = new StringTokenizer(ip, ".");
        try {
            ret[0] = (byte) (Integer.parseInt(st.nextToken()) & 0xFF);
            ret[1] = (byte) (Integer.parseInt(st.nextToken()) & 0xFF);
            ret[2] = (byte) (Integer.parseInt(st.nextToken()) & 0xFF);
            ret[3] = (byte) (Integer.parseInt(st.nextToken()) & 0xFF);
        } catch (Exception e) {
            logger.error("Error while getting IP byte array from string: {}", e.getMessage());
        }
        return ret;
    }

    public static String convertString(String input, String sourceEncoding, String targetEncoding) {
        try {
            return new String(input.getBytes(sourceEncoding), targetEncoding);
        } catch (UnsupportedEncodingException e) {
            logger.error("Error while converting string: {}", e.getMessage());
        }
        return input;
    }

    public static String convertBytesToString(byte[] byteArray, String encoding) {
        try {
            return new String(byteArray, encoding);
        } catch (UnsupportedEncodingException e) {
            logger.error("Error while converting bytes to string: {}", e.getMessage());
        }
        return new String(byteArray);
    }

    public static String convertBytesToString(byte[] byteArray, int offset, int length, String encoding) {
        try {
            return new String(byteArray, offset, length, encoding);
        } catch (UnsupportedEncodingException e) {
            logger.error("Error while converting bytes to string: {}", e.getMessage());
        }
        return new String(byteArray, offset, length);
    }

    public static String getIpStringFromBytes(byte[] ipBytes) {
        StringBuilder sb = new StringBuilder();
        sb.append(ipBytes[0] & 0xFF);
        sb.append('.');
        sb.append(ipBytes[1] & 0xFF);
        sb.append('.');
        sb.append(ipBytes[2] & 0xFF);
        sb.append('.');
        sb.append(ipBytes[3] & 0xFF);
        return sb.toString();
    }
}




























你可能感兴趣的:(基础,java,windows,开发语言)






    

  • 从零开始掌握Vue实例
程序员凡尘
Vue.js从入门到精通vue.js前端javascript

    从零开始掌握Vue实例：深入理解数据绑定与生命周期的核心秘诀引言简要介绍主题：在学习Vue.js的过程中，Vue实例是最基础也是最关键的部分。Vue实例是Vue应用的核心，它是数据、DOM元素和Vue组件之间的桥梁。掌握Vue实例的使用对于理解Vue的其他功能模块至关重要。目标和预期收获：通过本文，读者将学习到Vue实例的基本使用方法、如何通过数据绑定和响应式系统来管理应用的数据，以及Vue生命周
    

    • 

  • iMazing2024macOS和Win平台非常出色的第三方iOS设备管理软件
FLflStudio
CleanMyMacX2024TuxeraNTFSMac2024macosios

    iMazing3，是macOS和Windows平台非常出色的第三方iOS设备管理软件。在最新版本中，新增了一些功能，比如自动备份、Wi-Fi无线备份、铃声导入导出、App管理等。iMazing3支持对iPhone、iPad、iPodTouch等设备进行数据备份与恢复，并且支持对已备份的数据进行浏览和管理，比如可以单独导出照片或通讯录。iMazing3的Wi-Fi无线备份功能非常实用。只要第一次使用
    

    • 

  • Java之二维数组
2301_80176093
算法

    二维数组的声明及其基本语法声明：[行的坐标][列的坐标]arr基本语法：数据类型[][]数组名称=new数据类型[行数][列数]{初始化数据}代码示例int[][]arr={{1,2,3,4},{5,6,7,8},{9,10,11,12}};for(introw=0;row

    • 

  • 10月23日上午“大观念”统领下单元整体教学框架的建构与应用——李博
19吉林榆树焦艳丰

    关键词：大观念、单元整体教学.1.什么是单元整体教学.单元整体教学是以学习主题或学科核心内容为主线，整体分析学习内容和学生学习的基础上，突显关键问题的单元教学小学数学单元整体教学是以数学核心内容为线索，以学生素养发展为导向，以单元及单元的关键问题为重点的数学与实施(课标2022版）2.为什么要开展单元整体教学？(1)实施课程目标的实践路径(一)数学建议1.制定指向核心素养的教学目标（三会十一核]外
    

    • 

  • 使用css3实现【水波纹扩散效果】
自不量力的A同学
css3前端css

    使用css3实现【水波纹扩散效果】在CSS3中，我利用::before和::after伪元素以及动画（animation）来创建一个简单的水波纹扩散效果。下面是一个基础的示例：Html.container{position:relative;overflow:hidden;}.wave-effect{position:absolute;top:0;left:0;width:100%;height:
    

    • 

  • linux部署jar项目报错_linux jar 服务
国家级做梦冠军
linux部署jar项目报错

    关于linuxjar服务的搜索结果问题linux重启netty服务一些问题，请大神进linux上部署netty架构的服务时我一般启动的时候用下面脚本nohupjava-jarxxx-xxx.jarstart80808888&关闭的时候杀进程就可以了。今天部署的时候启动服务就报userBind，于是我查...杨冬芳2019-12-0120:26:501161浏览量回答数0问题Linux下Tomcat
    

    • 

  • java -jar 后台_【Java】部署jar包并后台运行
简单的艾伦
java-jar后台

    #Linux环境部署：#1、执行jar包的命令和在windows操作系统上是一样java-jarjarName-0.0.1-SNAPSHOT.jar;注:关闭服务器连接时会关闭此程序进程,(推荐测试可用)2、将jar程序设置成后台运行，并且将标准输出的日志重定向至文件msg.lognohupjava-jarjarName-0.0.1-SNAPSHOT.jar>msg.log2>&1&;注:nohu
    

    • 

  • linux 进程映射空间 libc,linux进程地址空间布局浅析
钟程杰
linux进程映射空间libc

    此文章是围绕该文章的思路进行总结的，原文记录的笔记详尽，在此基础上，我总结了本身的一下(想对浅显)。若是对具体细节想要了解的，能够访问这篇文章，在文章最后付了一段代码，跟该成程序的内存映射图，若是有哪里写的不正确，欢迎补充和指正。linux程序是什么抽象的来讲当咱们打开电脑点击应用程序图标，一个程序就运行起来了，可是在操做系统层面来看，实际上是产生了一个进程，这是一个程序的实体。ios接下来以li
    

    • 

  • ios-数据库-事务
-FIGHTING-
iOS封装数据库事务回滚存储

    概念事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务通常由高级数据库操纵语言或编程语言（如SQL，C++或Java）书写的用户程序的执行所引起，并用形如begintransaction和endtransaction语句（或函数调用）来界定。事务由事务开始(begintransaction)和事务结束(endtransaction)之间执行的全体操
    

    • 

  • Interface-接口
青山^
java开发语言

    接口（Interface）在编程中是一种规范或者契约，它定义了一组方法（在某些编程语言中还包括属性、事件等），但不提供这些方法的具体实现。接口只规定了类必须做什么，而不规定如何去做。实现接口的类必须实现接口中定义的所有方法。1.定义要点接口声明接口使用特定的关键字进行声明，例如在Java中使用interface关键字，在C#和TypeScript中也使用interface。方法声明接口中定义的方法
    

    • 

  • Linux中启动与停止jar包
橙子的胖胖
linux运维服务器

    Linux中启动与停止jar包启动jar包方式一：直接用命令启动命令：nohupjava-jar/myproject/yepcommongogogo/service_user/service_user.jar>>user.log&方式二：脚本的方式启动#!/bin/start.shnohupjava-jar/myproject/yepcommongogogo/service_user/servic
    

    • 

  • 【k8s系列】驾驭容器化未来：Kubernetes Pod的全面解析与简单实践
深情不及里子
kubernetes容器云原生

    一、前言在当今快速发展的云计算和容器化技术领域，Kubernetes已经崭露头角，成为自动化容器操作的开源平台。在这个生态系统中，Pod作为Kubernetes的最小和最简单的单元，扮演着至关重要的角色。Pod不仅是容器的集合，更是资源共享和协同工作的基础。作为初探容器化技术的爱好者，笔者也是在k8s学习过程中根据自己的理解分享一下这块的具体内容，希望对感兴趣的小伙伴有所帮助~二、Pod的基本概念
    

    • 

  • 每日精进，能听出英音和美音的不同啦
TQ蜗牛念念

    我想说，近一段时间的学习，积少成多，今天终于搞清楚一点点，英音和美音到底差别在什么地方。虽说音标能够看到不同，但因为基础不足，所以听大段对话或文章时，仍然不能很好的全部分辨，而且放在连读中会错乱。今天发现，英音和美音在r的发音上区别很大，而后反复播放BBC和VOA进行验证。美音很明显的卷舌，英音更平直。嗯，平时发音偏于美音，但我还是钟情英音。好好学习ｸﾞｯ!(๑•̀ㅂ•́)و✧图片发自App
    

    • 

  • 学配音怎么入门，自己在家怎么自学配音
配音新手圈

    配音学习可以归类为三点语言基础，基本功，然后就是表演。我们最好找一个好老师培训，好好练习普通话，基本功每天都要练;其次是气配声的问题，声音有了气息的支撑会更亮更稳。找老师学习正确的发声方式，少走夸路。一、学配音怎么入门很多人出于喜欢或者兴趣爱好，毕业之后或者工作之后选择了学习配音，有的立志要成为优秀的配音员，有的是希望配音能帮助自己说话谈吐更加的得体，气质得到提升，无论哪一种目的，必须承认一个事实
    

    • 

  • 【震惊】没有java环境也能运行jar，在不安装jdk下如何运行jar包
大海星辰798
javawindowsjava自动化

    1、首先把jdk下的jre拷贝出来，放到无java环境的Windows电脑2、编写运行脚本，path指向jre路径下的bin，-jar后为对应jar包@echooffsetpath=E:\projectDirectory\chongq\jar\ag-hikvision\jre\binSTART"middle""%path%\javaw"-jar***.jar3、这样就可以一键启动啦，是不是很简单！
    

    • 

  • javaScript如何判断一个对象是否存在某个属性
道长道长IOT
javascript开发语言

    在JavaScript中检查一个对象是否包含某个属性可以通过几种不同的方法实现。以下是几种常用的方法：1.in操作符in操作符可以用来检测一个属性是否存在于对象中，包括原型链上的属性。constobj={foo:'bar'};if('foo'inobj){console.log('fooisintheobject');}2.hasOwnProperty()方法hasOwnProperty()方法只
    

    • 

  • 一本读懂数据库发展史的书
人邮异步社区
数据库

    数据库及其存储技术，一直以来都是基础软件的主力。数据库系统的操作接口标准，也是应用型软件的重要接口，关系重大。作为最“有感”的系统软件，数据库的历史悠久、品类繁多、创新活跃。对数据库历史发展的介绍，有利于新一代技术人员的学习和传承；对未来演进的探究，有利于数据库开发者的思考和实践。如果想对当今数据库体系有一个深入的了解，最好学习一下数据库的发展史。这对于在我们脑海里建立数据库体系的知识大厦大有助益
    

    • 

  • linux 系统 shell 脚本，实现【查找进程，杀进程，启动 jar 包，打印输出日志】
ilyuc
运维相关

    先创建一个shell文件touchrestart.sh编写内容vimrestart.sh输入以下内容#!/bin/shAPP_NAME=dp.jarPID=`ps-ef|grepjava|grep$APP_NAME|awk'{print$2}'`echo"finddp.jarPID:$PID"kill-9$PIDecho"killeddp.jarPID:$PID"nohupjava-jardp.j
    

    • 

  • linux启动停止jar包、war包项目
小南城_
Linuxjarlinuxtomcat

    jar包项目启动命令:java-jara.jarnohup意思是不挂断运行命令,当账户退出或终端关闭时,程序仍然运行nohupjava-jara.jar&(&代表在后台运行)指定输出日志的文件nohupjava-jara.jar>nohup.out查看实时日志记录tail-fnohup.out查看最后1000条日志记录tail-1000nouhp.out停止命令:方式一:知道端口8095是系统启动
    

    • 

  • hive中的数据同步到hbase
流~星~雨
大数据相关hivehbasehadoop

    hive中的数据同步到hbase工作中遇到了这个工作，就是将hive中的数据同步到hbase中，然后java通过hbase相关的API来访问hbase中的数据。关于hadoop，hive，hbase这三个技术栈我写了两篇博客简单的分享了我对这三个技术栈的一些看法，在我目前的认知里，hadoop提供hdfs这个组件来存储大数据量的数据（相比于mysql，oracle这些关系型数据库），然后提供了Ma
    

    • 

  • 关于严格模式的具体分析
6230_
前端基础javascript开发语言ecmascript前端html改行学it学习方法

    1、什么是ES5概念：ES5指的是：ECMAScript5，它是JavaScript语言的国际标准。ES5通过对现有JavaScript方法添加语句和原生ECMAScript对象做合并实现标准化还引入了一个语法的严格变种，被称为“严格模式”。2、如何开启严格模式写法："usestrict"解释：只要将"usestrict"这个字符串放在代码的前方，后面的代码就会按照严格模式进行解释开启类型：局部开
    

    • 

  • 【思维导图实战派T8】01/21：思维导图线上训练
思维导图实战派静静

    我是南京博赞思维导图官方认证班静静。我相信在能力范围内尽全力去做，必有惊喜。指导老师：李凤艳童栎程汪志鹏主题词思维开发练习主题词思维接龙练习线条练习电话沟通主题的中心图练习目的：基础建设决定上层建筑时间：20分钟（超时）检视：基础练习看起来很容易，做起来还是有一定的难度。总是顾东又想着顾西，无从下手，感觉内心想表达的东西很多却又出不来！通过练习更深的检验出我平时行事上的种种不必要的坏习惯，比如超时
    

    • 

  • javaweb基于ssm框架校园即时服务平台管理系统设计与实现
ancen_73bd

    1、项目介绍系统开发平台：JDK1.8+Windows7+Maven3.6.1开发语言：Java后台框架：SSM前端：layui数据库：MySql5.7Navicat开发环境：IntellijIdea浏览器：Chrome或360浏览器本系统分为两个用户：学生、管理员。学生：可以发布任务、已接受任务、已发布任务、资料修改管理员：可以对用户进行管理、任务的管理、安全设置管理2、项目技术后端框架：SSM
    

    • 

  • 微信小程序之数据的绑定（与vue做对比）
井底的蜗牛
小程序小程序

    数据绑定与vue的对比Page({/***页面的初始数据*/data:{a:1,b:2,target:true,list:[{id:1,name:"wq",age:18},{id:2,name:"ce",age:20}]},})基础绑定vue的数据绑定：vue是使用{{}}双花括号内写data中的属性{{a+b}}或者{{1+2*3}}微信小程序数据绑定：也是使用{{}}写定义在data中的属性{
    

    • 

  • JavaScript 深度剖析 - 函数式编程范式
时光海丶
大前端javascript函数式编程

    函数式编程范式1.1函数式编程概念函数是一等公民高阶函数闭包1.2纯函数概念功能库lodash优劣纯函数的好处纯函数的副作用1.3柯里化(HaskellBrooksCurry)概念lodash中的柯里化函数总结1.4函数组合(compose)管道函数组合1.5Lodash中的fp模块1.6PointFree模式1.7函子Functor函子MayBe函子Either函子IO函子Task函子Point
    

    • 

  • Java设计模式七大原则-开闭原则
zoeil
Java设计模式

    开闭原则基本介绍开闭原则（OpenClosedPrinciple）是编程中最基础、最重要的设计原则一个软件实体如类，模块和函数应该对扩展开放(对提供方)，对修改关闭(对使用方)。用抽象构建框架，用实现扩展细节。当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则。例子publicclassOcp{pu
    

    • 

  • Express路由基础与高级功能深入解析
软考鸭
javascript帮助文档nodejs帮助文档expressgithub

    在Web开发中，路由是一个核心概念，它决定了应用程序如何响应客户端对特定端点的请求。这个端点由URI（或路径）和特定的HTTP请求方法（如GET、POST等）唯一确定。Express框架为Node.js应用程序提供了灵活而强大的路由机制，使得开发者可以轻松地构建出响应迅速且功能丰富的Web应用程序。在Express中，路由的定义遵循着一种简洁而直观的结构：app.METHOD(PATH,HANDL
    

    • 

  • 设计模式-七大原则-开闭原则
一个路过的小孩
java#设计模式设计模式开闭原则

    开闭原则OpenClosedPrinciple目录开闭原则基本介绍案例1运行结果分析demo输出结果基本介绍1.开闭原则OpenClosedPrinciple是编程中最基础、最重要的设计原则（ocp原则）2.一个软件的实体（eg：类），模块和函数应该对扩展开放（对提供方），对修改关闭（对使用方）用抽象构建框架，用实现扩展细节。3.当软件需求发生变化的时候，尽量通过扩展软件实体的行为实现变化，而不是
    

    • 

  • 2024.8.27基于ODDM调制的6G通感一体化系统波形设计：基础、挑战和未来方向
喝点辣椒油
信息与通信

    问题：需要减少移动场景下信道的时变特性造成的码间干扰。在高速移动环境下，ofdm技术需要更复杂的均衡和更多的新到开销，不同路径上传输的信号会受到多次多普勒频移和时移的影响，导致严重的性能损失。DD调制的优点：能把时变的TF信道转化为DD二维准时不变信道，因此对于高速移动的场景具有更强的鲁棒性。OTFS（正交时频空间）调制的发射博兴仍基于TF域上的正交脉冲，具有高带外泄漏发射和严重的码间干扰。正交时
    

    • 

  • 自然语言处理系列四十二》新词发现与短语提取》新词发现》代码实战
陈敬雷-充电了么-CEO兼CTO
自然语言处理人工智能nlpaichatgptgptjava

    注：此文章内容均节选自充电了么创始人，CEO兼CTO陈敬雷老师的新书《自然语言处理原理与实战》（人工智能科学与技术丛书）【陈敬雷编著】【清华大学出版社】文章目录自然语言处理系列四十二新词发现》代码实战短语提取算法原理总结自然语言处理系列四十二新词发现》代码实战新词发现是NLP的基础任务之一，通过对已有语料进行挖掘，从中识别出新词。上一篇文章已经对新词发现做了详细介绍，下面展示代码，HanLP工具提
    

    • 

  • Enum 枚举
120153216
enum枚举

    原文地址：http://www.cnblogs.com/Kavlez/p/4268601.html Enumeration
于Java 1.5增加的enum type...enum type是由一组固定的常量组成的类型，比如四个季节、扑克花色。在出现enum type之前，通常用一组int常量表示枚举类型。比如这样：
public static final int APPLE_FUJI = 0
    

    • 

  • Java8简明教程
bijian1013
javajdk1.8

            Java 8已于2014年3月18日正式发布了，新版本带来了诸多改进，包括Lambda表达式、Streams、日期时间API等等。本文就带你领略Java 8的全新特性。 
一.允许在接口中有默认方法实现
        Java 8 允许我们使用default关键字，为接口声明添
    

    • 

  • Oracle表维护 快速备份删除数据
cuisuqiang
oracle索引快速备份删除

    我知道oracle表分区，不过那是数据库设计阶段的事情，目前是远水解不了近渴。
当前的数据库表，要求保留一个月数据，且表存在大量录入更新，不存在程序删除。
为了解决频繁查询和更新的瓶颈，我在oracle内根据需要创建了索引。但是随着数据量的增加，一个半月数据就要超千万，此时就算有索引，对高并发的查询和更新来说，让然有所拖累。
为了解决这个问题，我一般一个月会进行一次数据库维护，主要工作就是备
    

    • 

  • java多态内存分析
麦田的设计者
java内存分析多态原理接口和抽象类

          “  时针如果可以回头，熟悉那张脸，重温嬉戏这乐园，墙壁的松脱涂鸦已经褪色才明白存在的价值归于记忆。街角小店尚存在吗？这大时代会不会牵挂，过去现在花开怎么会等待。
      但有种意外不管痛不痛都有伤害，光阴远远离开，那笑声徘徊与脑海。但这一秒可笑不再可爱，当天心
    

    • 

  • Xshell实现Windows上传文件到Linux主机
被触发
windows

    经常有这样的需求，我们在Windows下载的软件包，如何上传到远程Linux主机上？还有如何从Linux主机下载软件包到Windows下；之前我的做法现在看来好笨好繁琐，不过也达到了目的，笨人有本方法嘛；
我是怎么操作的：
1、打开一台本地Linux虚拟机，使用mount 挂载Windows的共享文件夹到Linux上，然后拷贝数据到Linux虚拟机里面；（经常第一步都不顺利，无法挂载Windo
    

    • 

  • 类的加载ClassLoader
肆无忌惮_
ClassLoader

    类加载器ClassLoader是用来将java的类加载到虚拟机中，类加载器负责读取class字节文件到内存中，并将它转为Class的对象（类对象），通过此实例的 newInstance()方法就可以创建出该类的一个对象。
 
其中重要的方法为findClass(String name)。
 
如何写一个自己的类加载器呢？
首先写一个便于测试的类Student
    

    • 

  • html5写的玫瑰花
知了ing
html5

    <html>
<head>
<title>I Love You!</title>
<meta charset="utf-8" />
</head>
<body>
<canvas id="c"></canvas> 
    

    • 

  • google的ConcurrentLinkedHashmap源代码解析
矮蛋蛋
LRU

    原文地址：
http://janeky.iteye.com/blog/1534352
简述
ConcurrentLinkedHashMap 是google团队提供的一个容器。它有什么用呢？其实它本身是对
ConcurrentHashMap的封装，可以用来实现一个基于LRU策略的缓存。详细介绍可以参见
http://code.google.com/p/concurrentlinke
    

    • 

  • webservice获取访问服务的ip地址
alleni123
webservice

    1. 首先注入javax.xml.ws.WebServiceContext,
@Resource
private WebServiceContext context;
2. 在方法中获取交换请求的对象。
javax.xml.ws.handler.MessageContext mc=context.getMessageContext();
com.sun.net.http
    

    • 

  • 菜鸟的java基础提升之道——————>是否值得拥有
百合不是茶

    1，c++，java是面向对象编程的语言，将万事万物都看成是对象；java做一件事情关注的是人物，java是c++继承过来的，java没有直接更改地址的权限但是可以通过引用来传值操作地址，java也没有c++中繁琐的操作，java以其优越的可移植型，平台的安全型，高效性赢得了广泛的认同，全世界越来越多的人去学习java，我也是其中的一员
 
 
 java组成：
    

    • 

  • 通过修改Linux服务自动启动指定应用程序
bijian1013
linux

    Linux中修改系统服务的命令是chkconfig (check config)，命令的详细解释如下: chkconfig
功能说明：检查，设置系统的各种服务。
语　　法：chkconfig [ -- add][ -- del][ -- list][系统服务] 或 chkconfig [ -- level  <</SPAN>
    

    • 

  • spring拦截器的一个简单实例
bijian1013
javaspring拦截器Interceptor

    Purview接口
package aop;
public interface Purview {
void checkLogin();
}
Purview接口的实现类PurviesImpl.java
package aop;
public class PurviewImpl implements Purview {
public void check
    

    • 

  • [Velocity二]自定义Velocity指令
bit1129
velocity

    什么是Velocity指令
在Velocity中，#set,#if, #foreach, #elseif, #parse等，以#开头的称之为指令，Velocity内置的这些指令可以用来做赋值，条件判断，循环控制等脚本语言必备的逻辑控制等语句，Velocity的指令是可扩展的，即用户可以根据实际的需要自定义Velocity指令
  自定义指令(Directive)的一般步骤
&nbs
    

    • 

  • 【Hive十】Programming Hive学习笔记
bit1129
programming

     第二章 Getting Started
1.Hive最大的局限性是什么？一是不支持行级别的增删改(insert, delete, update)二是查询性能非常差(基于Hadoop MapReduce）,不适合延迟小的交互式任务三是不支持事务2. Hive MetaStore是干什么的？Hive persists table schemas and other system metadata.
    

    • 

  • nginx有选择性进行限制
ronin47
nginx 动静　限制

    http {
limit_conn_zone $binary_remote_addr zone=addr:10m;
limit_req_zone $binary_remote_addr zone=one:10m rate=5r/s;...
server {...
location ~.*\.(gif|png|css|js|icon)$ {

    

    • 

  • java-4.-在二元树中找出和为某一值的所有路径 .
bylijinnan
java

    
/*
* 0.use a TwoWayLinkedList to store the path.when the node can't be path,you should/can delete it.
* 1.curSum==exceptedSum:if the lastNode is TreeNode,printPath();delete the node otherwise 
    

    • 

  • Netty学习笔记
bylijinnan
javanetty

    本文是阅读以下两篇文章时：
http://seeallhearall.blogspot.com/2012/05/netty-tutorial-part-1-introduction-to.html
http://seeallhearall.blogspot.com/2012/06/netty-tutorial-part-15-on-channel.html
我的一些笔记
===
    

    • 

  • js获取项目路径
cngolon
js

    //js获取项目根路径，如： http://localhost:8083/uimcardprj
function getRootPath(){
    //获取当前网址，如： http://localhost:8083/uimcardprj/share/meun.jsp
    var curWwwPath=window.document.locati
    

    • 

  • oracle 的性能优化
cuishikuan
oracleSQL Server

       在网上搜索了一些Oracle性能优化的文章，为了更加深层次的巩固[边写边记]，也为了可以随时查看，所以发表这篇文章。
    1.ORACLE采用自下而上的顺序解析WHERE子句，根据这个原理，表之间的连接必须写在其他WHERE条件之前，那些可以过滤掉最大数量记录的条件必须写在WHERE子句的末尾。（这点本人曾经做过实例验证过，的确如此哦！
    

    • 

  • Shell变量和数组使用详解
daizj
linuxshell变量数组

    Shell 变量
定义变量时，变量名不加美元符号（$，PHP语言中变量需要），如：
your_name="w3cschool.cc"
注意，变量名和等号之间不能有空格，这可能和你熟悉的所有编程语言都不一样。同时，变量名的命名须遵循如下规则：
首个字符必须为字母（a-z，A-Z）。
中间不能有空格，可以使用下划线（_）。
不能使用标点符号。
不能使用ba
    

    • 

  • 编程中的一些概念，KISS、DRY、MVC、OOP、REST
dcj3sjt126com
REST

    KISS、DRY、MVC、OOP、REST （1）KISS是指Keep It Simple,Stupid（摘自wikipedia），指设计时要坚持简约原则，避免不必要的复杂化。 （2）DRY是指Don't Repeat Yourself（摘自wikipedia），特指在程序设计以及计算中避免重复代码，因为这样会降低灵活性、简洁性，并且可能导致代码之间的矛盾。 （3）OOP 即Object-Orie
    

    • 

  • [Android]设置Activity为全屏显示的两种方法
dcj3sjt126com
Activity

    1. 方法1：AndroidManifest.xml 里，Activity的 android:theme  指定为" @android:style/Theme.NoTitleBar.Fullscreen" 示例:   <application      
    

    • 

  • solrcloud 部署方式比较
eksliang
solrCloud

    solrcloud 的部署其实有两种方式可选，那么我们在实践开发中应该怎样选择呢？ 第一种：当启动solr服务器时，内嵌的启动一个Zookeeper服务器，然后将这些内嵌的Zookeeper服务器组成一个集群。  第二种：将Zookeeper服务器独立的配置一个集群，然后将solr交给Zookeeper进行管理
 
谈谈第一种：每启动一个solr服务器就内嵌的启动一个Zoo
    

    • 

  • Java synchronized关键字详解
gqdy365
synchronized

    转载自：http://www.cnblogs.com/mengdd/archive/2013/02/16/2913806.html
多线程的同步机制对资源进行加锁，使得在同一个时间，只有一个线程可以进行操作，同步用以解决多个线程同时访问时可能出现的问题。
同步机制可以使用synchronized关键字实现。
当synchronized关键字修饰一个方法的时候，该方法叫做同步方法。
当s
    

    • 

  • js实现登录时记住用户名
hw1287789687
记住我记住密码cookie记住用户名记住账号

    在页面中如何获取cookie值呢?
如果是JSP的话,可以通过servlet的对象request 获取cookie,可以
参考:http://hw1287789687.iteye.com/blog/2050040
如果要求登录页面是html呢?html页面中如何获取cookie呢?
直接上代码了
页面:loginInput.html
代码:
<!DOCTYPE html PUB
    

    • 

  • 开发者必备的 Chrome 扩展
justjavac
chrome

    Firebug：不用多介绍了吧https://chrome.google.com/webstore/detail/bmagokdooijbeehmkpknfglimnifench
ChromeSnifferPlus：Chrome 探测器，可以探测正在使用的开源软件或者 js 类库https://chrome.google.com/webstore/detail/chrome-sniffer-pl
    

    • 

  • 算法机试题
李亚飞
java算法机试题

           在面试机试时，遇到一个算法题，当时没能写出来，最后是同学帮忙解决的。
       这道题大致意思是：输入一个数，比如4,。这时会输出：
          &n
    

    • 

  • 正确配置Linux系统ulimit值
字符串
ulimit

    在Linux下面部 署应用的时候，有时候会遇上Socket/File: Can’t open so many files的问题；这个值也会影响服务器的最大并发数，其实Linux是有文件句柄限制的，而且Linux默认不是很高，一般都是1024，生产服务器用 其实很容易就达到这个数量。下面说的是，如何通过正解配置来改正这个系统默认值。因为这个问题是我配置Nginx+php5时遇到了，所以我将这篇归纳进
    

    • 

  • hibernate调用返回游标的存储过程
Supanccy2013
javaDAOoracleHibernatejdbc

    注：原创作品，转载请注明出处。
    上篇博文介绍的是hibernate调用返回单值的存储过程，本片博文说的是hibernate调用返回游标的存储过程。
    此此扁博文的存储过程的功能相当于是jdbc调用select 的作用。
1，创建oracle中的包，并在该包中创建的游标类型。
---创建oracle的程
    

    • 

  • Spring 4.2新特性-更简单的Application Event
wiselyman
application

    1.1 Application Event
Spring 4.1的写法请参考10点睛Spring4.1-Application Event
请对比10点睛Spring4.1-Application Event
使用一个@EventListener取代了实现ApplicationListener接口,使耦合度降低;
1.2 示例
包依赖
<p
    

    •