Java

最新推荐文章于 2024-09-01 15:30:33 发布

weixin_34331102

最新推荐文章于 2024-09-01 15:30:33 发布

阅读量71

点赞数

文章标签： java python json

原文链接：https://my.oschina.net/yezijun/blog/1575562

版权

2019独角兽企业重金招聘Python工程师标准>>>

一. 数据类型相关

1.java泛型中<?>和<T>有什么区别

1.T自定义泛型和?通配符泛型
[1]ArrayList<T> arraylist=new ArrayList<T>();指定集合元素只能是T类型
[2]ArrayList<?> arraylist=new ArrayList<?>();集合元素可以是任意类型，这种没有意义,一般是方法中，只是为了说明用法.
[3]ArrayList<? extends E> al=new ArrayList<? extends E>();
泛型的限定：
? extends E:接收E类型或者E的子类型.
? super E:接收E类型或者E的父类型.

2.String类型转换int类型

方法一：

String str = "1024";
try {
    int a = Integer.parseInt(str);
} catch (NumberFormatException e) {
    e.printStackTrace();
}

方法二：

String str = "1024";
try {
    int b = Integer.valueOf(str).intValue()
} catch (NumberFormatException e) {
    e.printStackTrace();
}

3.字符串转换成map

方法一:

导入 Gson.jar ,int型的会自动转成double型 (字符串为Json格式)

    Gson gson = new Gson();  
    Map<String, Object> map = new HashMap<String, Object>();  
    map = gson.fromJson(str, map.getClass());

方法二:

导入5个包: commons-lang.jar、ezmorph-1.0.4.jar、commons-logging-1.1.1.jar、commons-collections.jar、commons-beanutils.jar .

    JSONObject jb = JSONObject.fromObject(str);  
    Map<String, Object> map = (Map<String, Object>)jb;

方法三:

split分割字符串

    String str = "color:red|font:yahei|width:800|height:300";  
    String[] strs = str.split("\\|");  
    Map<String, String> m = new HashMap<String, String>();  
    for(String s:strs){  
    String[] ms = s.split(":");  
    m.put(ms[0], ms[1]);  
    }

注意：非字符异常处理

4.截取特殊标识之前的字符串

String message="好好休息,天天健康";
String result=message.substring(0, message.lastIndexOf(","));
System.out.println(result);

//好好休息

5.list转换成字符串并用符号分隔

import org.apache.commons.lang.StringUtils;

List<String> list=new ArrayList<String>();
list.add("first");
list.add("second");
list.add("third");

StringUtils.join(list.toArray(), ",")

6.用符号分隔的字符串转换成list

String str = "a,b,c";  

List<String> result = Arrays.asList(str.split(","));

7.String和Date、Timestamp之间的转换

// string -> Date

String dateStr = "2018-08-17 12:34:23";  
        Date date = new Date();  
        //注意format的格式要与日期String的格式相匹配  
        DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");  
        try {  
            date = sdf.parse(dateStr);  
            System.out.println(date.toString());  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  

// Date -> String

String dateStr = "";  
        Date date = new Date();  
        //format的格式可以任意  
        DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
        DateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");  
        try {  
            dateStr = sdf.format(date);  
            System.out.println(dateStr);  
            dateStr = sdf2.format(date);  
            System.out.println(dateStr);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  

// String ->Timestamp

Timestamp ts = new Timestamp(System.currentTimeMillis());  
        String tsStr = "2018-08-17 11:49:45";  
        try {  
            ts = Timestamp.valueOf(tsStr);  
            System.out.println(ts);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  

// Timestamp -> String

Timestamp ts = new Timestamp(System.currentTimeMillis());  
        String tsStr = "";  
        DateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");  
        try {  
            //方法一  
            tsStr = sdf.format(ts);  
            System.out.println(tsStr);  
            //方法二  
            tsStr = ts.toString();  
            System.out.println(tsStr);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  

// Timestamp -> Date

Timestamp ts = new Timestamp(System.currentTimeMillis());  
        Date date = new Date();  
        try {  
            date = ts;  
            System.out.println(date);  
        } catch (Exception e) {  
            e.p

// Date -> Timestamp

Timestamp ts = new Timestamp(date.getTime());

8. list 并集, 交集, 差集, 无重复并集

//并集
list1.addAll(list2);
//交集
list1.retainAll(list2);
//差集
list1.removeAll(list2);
//无重复并集
list2.removeAll(list1);
list1.addAll(list2);

9.数组集合转换(String[] <==>List<String>)

//String[] ==> List<String>

String[] arr = new String[]{"s1","s2","s3"};
List<String> list = Arrays.asList(arr); 



//List<String> ==> String[]

List<String> list = new ArrayList<String>();
list.add("s1");
list.add("s2");
list.add("s3");
String[] arr = list.toArray(new String[list.size()]);

10.Calendar类

Calendar cal = Calendar.getInstance();
		 cal.get(Calendar.DATE);//1-31
		 cal.get(Calendar.DAY_OF_MONTH);//1-31
	     cal.get(Calendar.DAY_OF_WEEK);//从星期天开始计算，如果今天星期二，那么返回3
		 cal.get(Calendar.DAY_OF_YEAR);//
		 cal.get(Calendar.HOUR);//12小时制
		 cal.get(Calendar.HOUR_OF_DAY);//24小时制，一般使用这个属性赋值
		 cal.get(Calendar.MILLISECOND);//
		 cal.get(Calendar.MINUTE);//
		 cal.get(Calendar.SECOND);//
		 cal.get(Calendar.WEEK_OF_MONTH);//
		 cal.get(Calendar.WEEK_OF_YEAR);//
	     cal.get(Calendar.MONTH);//月份获取需要 +1，那么，赋值时需要 -1

1.运用这些常量赋值，通过这些常量获取值，同样可以通过它进行赋值

Calendar.YEAR
Calendar.MONTH
Calendar.DAY_OF_MONTH
Calendar.HOUR_OF_DAY
Calendar.MINUTE
Calendar.SECON

2.赋值时，week与mooth是需要注意，week需要制定setFirstDayOfWeek,然而，月份则需要加减1

3.赋值时，一般采用年、月、日、时、分、秒

主要赋值：

cal.set(Calendar.XXX, VVVV);//对以上每个字段（field）进行赋值，代码重复较大
cal.set(year,month,date,hour,minute,second);//分别对字段（field）进行赋值，效率高

取值语句：

cal.getMaximum(Calendar.DATE);
cal.get(Calendar.DATE);
cal.getMinimum(Calendar.DATE);
cal.setTimeInMillis(cal.getTime().getTime());
cal.setTimeInMillis(new Date().getTime());
主要计算：

cal1.roll(Calendar.MONTH,3);//一般不使用，原因是该方法只在一个月里面循环计算，其大小不会超过该月最值
cal1.add(Calendar.YEAR,-1);//使用 XX_OF_XX 的field进行加减计算效果更佳，而且计算准确
cal1.add(field,value);//

1.对于roll的计算，cal.roll(Calendar.DAY_OF_MONTH,32),虽然32已经超出了最大的可能31，但是cal实际是不会超出该月，而是把32减去该月天数之后，重新计算剩下的天数；

2。关于add的计算，cal1.add(Calendar.MONTH, 1); 如果当前为8-31，那么，加一个月的话就是9-30，这个才是真正的准确

// 当天
public String getThisToday(){
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	Calendar cal = Calendar.getInstance();
	cal.set(Calendar.HOUR_OF_DAY,0);
	cal.set(Calendar.MINUTE, 0);
	cal.set(Calendar.SECOND,0);
	String start = sdf.format(cal.getTime());
	cal.set(Calendar.HOUR_OF_DAY,23);
	cal.set(Calendar.MINUTE, 59);
	cal.set(Calendar.SECOND,59);
	String end = sdf.format(cal.getTime());
	return start+"|"+end;
}

// 本周
public String getThisWeekDate(){
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	Calendar ca = Calendar.getInstance();
	ca.setFirstDayOfWeek(Calendar.MONDAY);
	ca.set(Calendar.DAY_OF_WEEK,Calendar.SUNDAY);
	ca.set(ca.get(Calendar.YEAR), ca.get(Calendar.MONTH),ca.get(Calendar.DATE),23,59,59);
	String end = sdf.format(ca.getTime());
	ca.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
	ca.set(Calendar.HOUR_OF_DAY,0);
	ca.set(Calendar.MINUTE, 0);
	ca.set(Calendar.SECOND,0);
	String start = sdf.format(ca.getTime());
	return start+"|"+end;
}

//本月日期段
public String getThisMonthDate(){
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	Calendar cc2 = Calendar.getInstance();
	int maxMonthDay = cc2.getActualMaximum(Calendar.DAY_OF_MONTH);
	cc2.set(cc2.get(Calendar.YEAR), cc2.get(Calendar.MONTH),maxMonthDay,23,59,59);
	String end = sdf.format(cc2.getTime());
	cc2.set(cc2.get(Calendar.YEAR), cc2.get(Calendar.MONTH),1,0,0,0);
	String start = sdf.format(cc2.getTime());
	return start+"|"+end;
}

二.HTTP请求

1.GET 和 POST 的区别

GET在浏览器回退时是无害的，而POST会再次提交请求。

GET产生的URL地址可以被保存为书签，而POST不可以。

GET请求会被浏览器主动缓存，而POST不会，除非手动设置。

GET请求只能进行url编码，而POST支持多种编码方式。

GET请求参数会被完整保留在浏览器历史记录里，而POST中的参数不会被保留。

GET请求在URL中传送的参数是有长度限制的，而POST没有。

对参数的数据类型，GET只接受ASCII字符，而POST没有限制。

GET比POST更不安全，因为参数直接暴露在URL上，所以不能用来传递敏感信息。

GET参数通过URL传递，POST放在Request body中。

三.其他

1.文档注释

标签	描述	示例
@author	标识一个类的作者	@author description
@deprecated	指名一个过期的类或成员	@deprecated description
{@docRoot}	指明当前文档根目录的路径	Directory Path
@exception	标志一个类抛出的异常	@exception exception-name explanation
{@inheritDoc}	从直接父类继承的注释	Inherits a comment from the immediate surperclass.
{@link}	插入一个到另一个主题的链接	{@link name text}
{@linkplain}	插入一个到另一个主题的链接，但是该链接显示纯文本字体	Inserts an in-line link to another topic.
@param	说明一个方法的参数	@param parameter-name explanation
@return	说明返回值类型	@return explanation
@see	指定一个到另一个主题的链接	@see anchor
@serial	说明一个序列化属性	@serial description
@serialData	说明通过writeObject( ) 和 writeExternal( )方法写的数据	@serialData description
@serialField	说明一个ObjectStreamField组件	@serialField name type description
@since	标记当引入一个特定的变化时	@since release
@throws	和 @exception标签一样.	The @throws tag has the same meaning as the @exception tag.
{@value}	显示常量的值，该常量必须是static属性。	Displays the value of a constant, which must be a static field.
@version	指定类的版本	@version info

四.基础相关

1.java中进制之间的转换

//十进制转其他进制

Integer.toHexString(10);　//将10转换为十六进制，返回字符串类型
Integer.toOctalString(10);　//将10转为八进制，返回字符串类型
Integer.toBinaryString(10);　//将10转为二进制，返回字符串类型

//十六进制转十进制，例如：0xFFFF

Integer.valueOf("FFFF",16).toString();　　//valueOf()方法返回Integer类型，调用toString()返回字符串
Integer.parseInt("FFFF",16);　　//返回int基本数据类型
Integer.toString(0xFFFF);　　//该方法可直接传入表示十六进制数字的基本数据类型，方法返回字符串

//八进制转十进制，例如：017

Integer.valueOf("17",8).toString();　　//valueOf()方法返回Integer类型，调用toString()返回字符串
Integer.parseInt("17",8);　　//返回int基本数据类型
Integer.toString(017);　　//该方法可直接传入表示八进制数字的基本数据类型，方法返回字符串

//二进制转十进制，例如：0101

Integer.valueOf("0101",2).toString();　　//valueOf()方法返回Integer类型，调用toString()返回字符串
Integer.parseInt("0101",2);　　//返回int基本数据类型

//对于二进制、八进制和十六进制之间的转换，可先转换为十进制，在用十进制转多进制的相应方法进行转换
//例如将十六进制0xFF转为二进制

Integer.toBinaryString(Integer.valueOf("FF",16));　　
//或者
Integer.toBinaryString(Integer.parseInt("FF",16));

//对于输入的表示十六进制的字符串，需要先截取数字子串，再用valueOf()或parseInt()方法进行转换为十进制
//例如输入0xFF
String s = "0xFF";
Integer.valueOf(s.subString(2,s.length()),16)；
//对于valueOf方法，可以用于基本数据类型的装箱及多进制到十进制之间的转换。

2.Double型加减乘除

import java.math.BigDecimal;
private static final int DEF_DIV_SCALE = 10;
BigDecimal b1 = new BigDecimal(double1.toString());
BigDecimal b2 = new BigDecimal(double2.toString());

Double result = new Double(b1.add(b2).doubleValue()); //加
result=new Double(b1.subtract(b2).doubleValue()); //减
result=new Double(b1.multiply(b2).doubleValue()); //乘
result=new Double(b1.divide(b2, DEF_DIV_SCALE, BigDecimal.ROUND_HALF_UP).doubleValue()); //除

/**
* * 两个Double数相除，并保留scale位小数 *
*
* @param b1 *
* @param b2 *
* @param scale *
* @return Double
*/

public Double divide(BigDecimal b1, BigDecimal b2, int scale) {
   if (scale < 0) {
    throw new IllegalArgumentException("保留小数点后位数必须是正整数或者0");
   }
   return new Double(b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue())
   return new Double(b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue());
}

转载于:https://my.oschina.net/yezijun/blog/1575562