1:Math&大数据类四则运算

X abs(X x)

double random()         产生随机数

double ceil(double a)   向上取整

double floor(double a)  向下取整

X max/min(X x,X y)

double pow(double a, double b)   返回a的b次方

round(double a)    四舍五入,即该值加上0.5,然后去floor

例子:

/*
* Math:
* 静态常量:
* 1:Math.E : 自然对数的底数 Math.PI: 圆周率
* 主要方法:
* 2:public static double abs(int c) 取绝对值
* 3:public static double ceil(double a) 向上取整
* public static double floor(double a) 向下取整
* 4:public static double max(double a,double b) 取最大值
* public static double min(double a,double b) 取最小值
* 5:public static double pow(double a, double b) 返回第一个参数的第二个参数次幂的值。
* 6:public static double random() [0,1)
* 7:public static long round(double a) 四舍五入
*/
public class Demo { public static void main(String[] args) {
//
System.out.println(Math.E);
System.out.println(Math.PI);
//2获取绝对值
int a = -10;
System.out.println(Math.abs(a));
byte b = 10;
System.out.println(Math.abs(b));
//
System.out.println(Math.ceil(1.1));
System.out.println(Math.ceil(1.8));
System.out.println(Math.ceil(-1.1));
System.out.println(Math.ceil(-1.8)); System.out.println(Math.floor(1.1));
System.out.println(Math.floor(1.8));
System.out.println(Math.floor(-1.1));
System.out.println(Math.floor(-1.8)); //
System.out.println(Math.max(10, 20));
System.out.println(Math.min(10, 20)); //
System.out.println(Math.pow(10, 3));
//
System.out.println(Math.random()); //
System.out.println(Math.round(1.1));
System.out.println(Math.round(1.8));
System.out.println(Math.round(-1.1));
System.out.println(Math.round(-1.8));
} }

注释:产生随机数的random实际调用的是Random类随机数,方法如下:

public static double random() {

Random rnd = randomNumberGenerator;

if (rnd == null) rnd = initRNG();

return rnd.nextDouble();

}

2:Random

(1)是产生伪随机数的类。

(2)构造方法:

A:Random r = new Random();  //每次调用该对象时,默认产生不同的种子

B:random r = new Random(long seed);

注意:种子一样,随机数一样。

例子:

import java.util.Random;

/*
* Random类:伪随机数生成类
* 构造方法:
* 1:public Random() 使用一个任意的不重复的数作为种子生成对象
* 2:public Random(long seed) 使用一个指定的数作为种子生成对象
*
* 主要方法:
* 3:public int nextInt() 及其重载,根据不同类型生成随机数,
* 4:public int nextInt(int n) 产生[0,n)之间的随机数
*/
public class Demo2 { public static void main(String[] args) { //
Random random = new Random();
for (int i = 0; i < 10; i++) {
System.out.println(random.nextInt()); //空参构造器每次产生的种子不一样,产生的随机数不一样
}
System.out.println("==============================");
Random random2 = new Random();
for (int i = 0; i < 10; i++) {
System.out.println(random2.nextInt()); //空参构造器每次产生的种子不一样,产生的随机数不一样
} //
System.out.println("==============================");
Random random3 = new Random(1l); //种子一样,产生的随机数也一样
for (int i = 0; i < 10; i++) {
System.out.println(random3.nextInt());
}
System.out.println("=============================="); //种子一样,产生的随机数也一样
Random random4 = new Random(1l);
for (int i = 0; i < 10; i++) {
System.out.println(random4.nextInt());
}
System.out.println("=============================="); //
Random random5 = new Random();
for (int i = 0; i < 100; i++) {
System.out.println(random5.nextInt(100)); //产生[0,100)之间的随机整数
} }
}

(3)掌握的方法:

public int nextInt(int n):产生在[0,n)之间的随机数。

3:System(掌握)

(1)系统类,通过了静态的方法供我们使用。

(2)要掌握的功能:

A:exit(int i)  //退出VM   终止当前正在运行的 Java 虚拟机,i=0,便是正常退出,i!=0,表示异常退出。

B:currentTimeMillis() //获取当前毫秒值  可以用来测算程序运行的时间

long l1=System.currentTimeMillis();

//code...

long l2=System.currentTimeMillis();

System.out.println(l2-l1);  //输出中间代码运行时间

C:arraycopy() //arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

从指定源数组中复制一个数组,复制从指定的位置开始,到目标数组的指定位置结束

D:public static Properties getProperties()   获取系统属性值

例子:

/*
* System类:系统类
* 主要方法:
* 1:public static void gc() 运行垃圾回收器。
* 2:public static void exit(int status) 终止当前正在运行的 Java 虚拟机。
* 3:public static long currentTimeMillis() 获取当前时间毫秒值,根据协调世界时间。可以用来检测程序运行时间
* 4:public static Properties getProperties() 确定当前的系统属性。
*/
public class Demo3 { public static void main(String[] args) { //3:获取当前时间毫秒值
System.out.println(System.currentTimeMillis()); //4:获取系统属性
System.out.println(System.getProperties()); //2:
System.out.println("i love java!");
System.exit(0);
System.out.println("i hate java!");
} }

gc():调用 gc()方法暗示着 Java 虚拟机做了一些努力来回收未用对象

finalize():当垃圾回收器确定不存在对该对象的更多引用时,由对象的垃圾回收器调用此方法。子类重写 finalize 方法,以配置系统资源或执行其他清除。

4:BigInteger类和Bigdecimal类

import java.math.BigInteger;
import java.util.Arrays; /*
* BigInteger:支持任意精度的整数
* 方法:
* public BigInteger add(BigInteger val) 加法
* public BigInteger subtract(BigInteger val) 减法
* public BigInteger multiply(BigInteger val) 乘法
* public BigInteger divide(BigInteger val) 除法
* public BigInteger[] divideAndRemainder(BigInteger val)
* 构造器:
* BigInteger(String val) //将 BigInteger 的十进制字符串表示形式转换为 BigInteger。
*/ /*
* BigDecimal:支持任意精度的小数
* 方法:
* public BigDecimal add(BigDecimal augend) 加法
* public BigDecimal subtract(BigDecimal subtrahend) 减法
* public BigDecimal multiply(BigDecimal multiplicand) 乘法
* public BigDecimal divide(BigDecimal divisor) 除法
* public BigDecimal[] divideAndRemainder(BigDecimal divisor) //返回商和余数
* 构造器:
* BigDecimal(String val) //将BigDecimal 的字符串表示形式转换为 BigDecimal。
public class Demo4 { public static void main(String[] args) { BigInteger bi = new BigInteger("11111111111"); // 将 BigInteger 的十进制字符串表示形式转换为 BigInteger
BigInteger bi2 = new BigInteger("2"); System.out.println(bi.add(bi2));
System.out.println(bi.subtract(bi2));
System.out.println(bi.multiply(bi2));
System.out.println(bi.divide(bi2)); System.out.println(Arrays.toString(bi.divideAndRemainder(bi2))); System.out.println(4099.99-969.01);//3130.9799999999996
BigDecimal b1=new BigDecimal(4099.99);
BigDecimal b2=new BigDecimal(969.01); //误差减小了一点点
System.out.println(b1.subtract(b2));//3130.979999999999790816218592226505279541015625 } }

5:日期(理解)

(1)Date:

表示一个日期类。大部分方法过时,被Calendar替代。

构造方法:

Date d = new Date();

Date d = new Date(long time);

获取毫秒值:

public long getTime()// 获取毫秒数

public void setTime(long time) //设置毫秒数

例子:

import java.util.Date;

/*
* Date类:
* 类 Date 表示特定的瞬间,精确到毫秒。就是表示时间的。
* 构造方法:
* 1:public Date()分配 Date 对象并初始化此对象,以表示分配它的时间(精确到毫秒), 获取当前时间
* 2:public Date(long date) 根据毫秒值,创建日期对象。
* 主要方法:
* 3:public long getTime() 获取毫秒数
* 4:public void setTime(long time) 设置毫秒数
*/
public class Demo5 { public static void main(String[] args) { //获取当前时间
Date date = new Date();
System.out.println(date); Date date3 = new Date(System.currentTimeMillis());
System.out.println(date3); //
Date date2 = new Date(1645645766712l);
System.out.println(date2); //3,4
System.out.println("=========================");
Date date4 = new Date();
long time = date4.getTime();
System.out.println(time); date4.setTime(1234566788l);
System.out.println(date4);
} }

(2)DateFormat:

对日期进行格式化和对字符串解析的类

String -- Date:

解析:par  se(转换的意思)

//将一个字符串日期,转成一个date日期>>>经常做的

String date = "2014年09月25日 12时24分15";

DateFormat dateFormat2 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss");

Date parse = dateFormat2.parse(date);

System.out.println(parse);

Date -- String:

格式化:format(“要符合的日期格式”)

DateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日  HH时mm分ss秒");//格式 yyyy年MM月dd日  HH时mm分ss秒

String format = dateFormat.format(new Date());

System.out.println(format);

例子:

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date; /*
* 日期格式化类:
* DateFormat:是日期/时间格式化子类的抽象类
* public final String format(Date date) 将一个 Date 格式化为日期/时间字符串。
* public Date parse(String source) 将字符串转成Date对象
* SimpleDateFormat:具体的时间格式化工具
* 构造:
* public SimpleDateFormat() 空参构造,使用默认格式
* public SimpleDateFormat(String pattern) 根据指定模式创建日期格式化类对象
*/
public class Demo6 { public static void main(String[] args) throws ParseException {
//日期对象转字符串
Date date = new Date(); //创建要被格式化的日期对象
System.out.println(date); SimpleDateFormat sdf = new SimpleDateFormat(); //使用默认的格式创建日期格式化对象
String format = sdf.format(date); //调用日期格式化对象的方法格式化日期
System.out.println(format); //打印格式化好的字符串日期 System.out.println("=================="); Date date2 = new Date(); //创建要被格式化的日期对象
String model = "yyyy年MM月dd日 HH:mm:ss"; //定义日期表示模式(格式)
SimpleDateFormat sdf2 = new SimpleDateFormat(model); //使用指定的格式创建日期格式化对象
String format2 = sdf2.format(date2); //调用日期格式化对象的方法格式化日期
System.out.println(format2); //打印格式化好的字符串日期 System.out.println("===================");
//字符串转日期对象
String sDate = "2015-04-04 11:48:43"; //定义字符串类型的日期
String model2 = "yyyy-MM-dd HH:mm:ss"; //定义日期表示模式(格式)
SimpleDateFormat sdf3 = new SimpleDateFormat(model2);//使用指定的格式创建日期格式化对象
Date parseDate = sdf3.parse(sDate); //调用日期格式化对象的方法将日期按照指定的格式转成Date对象
System.out.println(parseDate); //打印Date对象
} }

(3)Calendar:

日历类,对日期进行了更细的划分,可以获取日历的每个字段值。

根据日历字段获取对应的值:

get(Calendar.相应字段)

设置年月日:

一般情况下,都是由getInstance()获取Calendar对象

在特殊业务需求时,需要进行判断

set(int year,int month,int date)

返回一个Date类型的对象

getTime()

修改指定日历的值:

add(int field,int value) //此处的field要用Calendar来调用,如Calendar.YEAR

例子:

import java.util.Calendar;

/*
* Calendar:日历类对象
*
* 创建对象:1:Calendar rightNow = Calendar.getInstance();
*
* 主要方法:
* 2:public int get(int field) 通过指定的字段(key),获取对应的值
* 注意:月份是0-11 其余字段正常
* 3:public abstract void add(int field,int amount) 给指定的字段值添加指定的量
* 4:public final void set(int year, int month, int date) 给指定的字段赋值,但是是直接给值
* public final Date getTime() 将日历对象转成Date对象
*/
public class Demo7 { public static void main(String[] args) {
//
Calendar rightNow = Calendar.getInstance();//生成的是Calemdar类的子类GregorianCalendar的对象
System.out.println(rightNow); //
int year = rightNow.get(Calendar.YEAR);
System.out.println(year); //3:public abstract void add(int field,int amount)
rightNow.add(Calendar.YEAR, 1);
System.out.println(rightNow.get(Calendar.YEAR)); // 计算机中2016.3.4 现实生活中 2016.4.4
rightNow.add(Calendar.MONTH, 1);
System.out.println(rightNow.get(Calendar.MONTH));// 计算机中2016.4.4 现实生活中 2016.5.4 rightNow.add(Calendar.DAY_OF_MONTH, -10); // 计算机中2016.3.24 现实生活 2016.4.24
System.out.println(rightNow.get(Calendar.MONTH));
System.out.println(rightNow.get(Calendar.DAY_OF_MONTH)); //4:public final void set(int year, int month, int date)//设置日期,并且以Data类型对象输出
Calendar rightNow2 = Calendar.getInstance();
rightNow2.set(2015, 0,1);
System.out.println(rightNow2.getTime());
} }
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date; /*
* 请计算伟大祖国多少天了?
*/
public class Test { public static void main(String[] args) throws ParseException { //得到现在时间的毫秒值
long rightNow = new Date().getTime();
//得到建国时间的毫秒值
// 方法1:
// String sBirthday = "1949-10-01";
// String model = "yyyy-MM-dd";
// DateFormat df = new SimpleDateFormat(model);
// Date dBirthday = df.parse(sBirthday); // 方法2
Calendar cBirthday = Calendar.getInstance();
cBirthday.set(1949, 10, 1);
Date dBirthday = cBirthday.getTime(); //Calendar的getTime 返回Date对象
long lBirthday = dBirthday.getTime(); //Date的getTime 返回Long类型的毫秒值 //根据毫秒值计算天数
long time = rightNow-lBirthday;
int days = (int)(time/1000/60/60/24); System.out.println(days);
}
}
import java.util.Calendar;

/*
* 如何获得任意年份二月有多少天?
*/
public class Test2 { public static void main(String[] args) { int fdays = getFdays(2004);
System.out.println(fdays);
} public static int getFdays(int year) {
Calendar calendar = Calendar.getInstance();
calendar.set(year, 2, 1);
calendar.add(Calendar.DAY_OF_MONTH, -1); return calendar.get(Calendar.DAY_OF_MONTH);
} }
import java.util.Calendar;
/*
* 获取昨天的此时此刻
*/
public class Test3 { public static void main(String[] args) { Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DAY_OF_MONTH, -1);
System.out.println(calendar.getTime());
} }

6:正则表达式(掌握用法)

(1)符合一定规则的字符串。

(2)规则:

A:字符

x 字符 x

\\ 反斜线字符

\r 回车符

\n 换行符

B:字符类

[abc] a、b 或 c

[^abc] 任何字符,除了 a、b 或 c

[a-zA-Z] a 到 z 或 A 到 Z,两头的字母包括在内

[0-9] 包括0-9之间的字符

C:预定义字符类

. 任何字符

\d 数字:[0-9]

\w 单词字符:[a-zA-Z_0-9]

D:边界匹配器

^ 行的开头

$ 行的结尾

\b 单词边界

就是指这里出现的不能使单词字符。

he;wor xixi

E:Greedy 数量词

X? X,一次或一次也没有

X* X,零次或多次

X+ X,一次或多次

X{n} X,恰好 n 次

X{n,} X,至少 n 次

X{n,m} X,至少 n 次,但是不超过 m 次

F:组的概念(按照小括号从左开始编号,每一个对应着一个组)

(a(b(c)d(e)))

第一组:a(b(c)d(e))

第二组:b(c)d(e)

第三组:c

第四组:e

将来我们就可以通过编号来获取组中内容。组0表示整个表达式。

(3)通过String类的功能使用正则表达式

A:判断功能

public boolean matches(String regex)

B:分割功能

public String[] split(String regex)

C:替换功能

public String replaceAll(String regex,String newString)

记住:

叠次:

在同一个字符串中,右边引用左边:"(.)\\1+"

在后一个字符串中引用前面的字符串的组内容:"(.)\\1+","$1"

例子:

import java.util.Arrays;

/*
* 正则表达式:
* 字符串结合正则的使用
* 1:public boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式。
* 2:public String[] split(String regex) 按照指定规则切割字符串,生成对应字符串数组
* 3:public String replaceAll(String regex, String 替换的字符串)
*/
public class Demo2 { public static void main(String[] args) {
//1:
//定义被匹配的字符串
String s = "qxq";
String s2 = "qeq";
//定义正则规则
String regex = "q[aeiou]q"; boolean matches = s.matches(regex);
System.out.println(matches);
boolean matches2 = s2.matches(regex);
System.out.println(matches2); //2:
/*
切割字符串"aa,bb,cc"
切割字符串"aa.bb.cc"
切割字符串"-1 99 4 23"
切割字符串"-1 99 4 23"
*/
//定义被匹配的字符串
String s3 = "aa,bb,cc"; String regex2 = ",";
String[] split = s3.split(regex2);
// System.out.println(Arrays.toString(split));
for (int i = 0; i < split.length; i++) {
String string = split[i];
System.out.print(string+" ");
}
System.out.println("=========================="); String s4 = "aa.bb.cc";
String regex3 = "\\."; // .需要转义,\也需要转义
String[] split2 = s4.split(regex3);
System.out.println(Arrays.toString(split2)); System.out.println("==========================");
String s5 = "-1 99 4 23";
String regex4 = " ";
String[] split3 = s5.split(regex4);
System.out.println(Arrays.toString(split3)); System.out.println("==========================");
String s6 = "-1 99 4 23";
String regex5 = " +"; //+代表一个或者多个空格
String[] split4 = s6.split(regex5);
System.out.println(Arrays.toString(split4)); //3:字符串中,凡是数字就使用"*"代替
String s7 = "asdfsa21323sdf21";
String regex6 = "\\d"; // \d代表数字 ,加一个\表示转义
// String regex6 ="[0-9]"; //与上面的等价
// String regex6 ="[0,1,2,3,4,5,6,7,8,9]"; //与上面的等价
System.out.println(s7.replaceAll(regex6, "*"));
} }

例子(重要):

import java.util.Arrays;

/*
* 正则表达式分组:
* 0 ((A)(B(C)))
* 1 (A)(B(C))
* 2 \A
* 3 B(C)
* 4 \C
* 1:叠词切割:"sdqqfgkkkhjppppkl "
* 2:将叠词替换成单个字符
*/
public class Demo3 { public static void main(String[] args) {
String s = "sdsqqfgkkkhjppppkl";
String regex = "(.)\\1+"; //按照重复出现的字符切割
String[] arr= s.split(regex); System.out.println(Arrays.toString(arr)); String s2 = "sdaaafghccccjkqqqqql";
String regex2 = "(.)\\1+";
String replaceAll = s2.replaceAll(regex2, "$1"); //按连续重复出现的字符换成单个字符
System.out.println(s2);
System.out.println(replaceAll); } }

 (4)

  常规的正则使用:Pattern与Mathcher

  常规使用步骤:

    Pattern p = Pattern.compile("a*b");

    Matcher m = p.matcher("aaaaab");

    boolean b = m.matches();

例子:

/*String str = "da jia zhu yi le, ming tian bu fang jia, xie xie!";想要获取3个字母组成的单词
*/ String str = "da jia zhu yi le, ming tian bu fang jia, xie xie!";
String reg = "\\b[a-z]{3}\\b";
Pattern p = Pattern.compile(reg);
Matcher m = p.matcher(str);
while(m.find())
{
System.out.println(m.start()+"..."+m.end());
System.out.println("sub:"+str.substring(m.start(),m.end()));
System.out.println(m.group());
}

(5)案例:

A:校验电话号码

    /**
* 正则表达式:验证手机号
*/
public static final String REGEX_MOBILE = "^((17[0-9])|(14[0-9])|(13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$";

B:校验qq邮箱

/**
* 是否是邮件校验
*/
public class test9 {
public static void main(String[] args) {
String email="22282815808@qq.com";
checkEmail(email);
}
public static void checkEmail(String email){
String regex="[1-9][0-9]{1,14}@qq.com";
Boolean b=email.matches(regex);
System.out.println(b);
}
}

C:我要学编程

/**
* 我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
* 将字符串还原成:“我要学编程”。
*/
public class Test10 {
public static void main(String[] args) {
// 先将字符串中的.去掉, .去掉后,字符串就变了,所以用字符串的替换.
String s = "我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程";
String s2=s.replaceAll("\\.",""); // 将没有.的字符串进行叠词的处理,多个重叠的字保留一个.
String s3=s2.replaceAll("(.)\\1+","$1");
System.out.println(s3);
}
}

D:检验qq号是否符合规则

例子:

/*
* 请验证一个字符串是否为qq号 要求:5-15位数字,不能以0开头
*
* 经过对比,发现使用正则表达式匹配字符串更简单。
*/
public class Demo { public static void main(String[] args) {
String qq = "12345";
System.out.println(checkQQ(qq));
System.out.println(checkQQ2(qq));
}
private static boolean checkQQ(String qq) {
//定义布尔类型变量,记录判断结果,默认是正确的
boolean flag = true; if (qq.length() < 5 || qq.length() > 15) { //判断是否长度不符
flag = false;
} else { //长度符合
if (qq.startsWith("0")) { //判断是否以0开头
flag = false;
} else { //不以0开头
char[] chs = qq.toCharArray(); //获取qq字符串的字节数组 for (int i = 0; i < chs.length; i++) { //遍历字符数组
if (!(chs[i] >= '0' && chs[i] <= '9')) { //判断是否不是数字
flag = false;
break;
}
} }
}
return flag;
} private static boolean checkQQ2(String qq) {
String regex = "[1-9][0-9]{4,14}";//定义一个正则规则
boolean b = qq.matches(regex); //让字符串去适应判断这个规则
return b;
} }

Math、Random、System、BigInteger、Date、DateFormat、Calendar类,正则表达式_DAY14的更多相关文章

  1. 与时间有关的类Date,DateFormat,Calendar

    Date类用于表示日期和时间.它没考虑国际化问题,所以又设计了另外两个类. Calendar类: 主要是进行日期字段之间的相互操作. 编程实例:计算出距当前日期时间315天后的日期时间,并使用”xxx ...

  2. Java基础 与时间日期相关的类:System -Date -SimpleDateFormat -Calendar类 -解决后缀.000Z 的时区问题

    笔记总结: /**与时间相关的类:System_Date_SimpleDateFormat_Calendar类 * 1.system 类下的currentTimeMillis() * 输出从1970年 ...

  3. Java从零开始学三十一(DATE和Calendar类)

    一.Date类 Date类是一个相对较为简单的操作类,在使用中直接使用java.util.Date类的构造方法并进行输出就可以得到一个完整的日期 二.Calendar类 Calendar类可以将取得的 ...

  4. JAVA基础——Date和Calendar类

    1计算某一月份的最大天数 Calendar time=Calendar.getInstance(); time.clear(); time.set(Calendar.YEAR,year); //yea ...

  5. 黑马程序员——JAVA基础之System,Runtime,Date,Calendar,Math

    ------- android培训.java培训.期待与您交流! ---------- System:  类中的方法和属性都是静态的. out:  标准输出,默认是控制台. in:标准输入,默认是键盘 ...

  6. 浅析Java源码之Math.random()

    从零自学java消遣一下,看书有点脑阔疼,不如看看源码!(๑╹◡╹)ノ""" ​ JS中Math调用的都是本地方法,底层全是用C++写的,所以完全无法观察实现过程,Jav ...

  7. 正则表达式、Calendar类、SimpleDateFormat类、Date类、BigDecimal类、BigInteger类、System类、Random类、Math类(Java基础知识十四)

    1.正则表达式的概述和简单使用 * A:正则表达式(一个字符串,是规则)     * 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串.其实就是一种规则.有自己特殊的应用. * B: ...

  8. 几种常见类的使用(System,Runtime,Math,Date,Calendar,Random)

    一:System 1.介绍 System:类中的方法和属性都是静态的. out:标准输出,默认是控制台. in:标准输入,默认是键盘. 2.properties 获取系统属性信息:Properties ...

  9. 14-03 java BigInteger类,BigDecimal类,Date类,DateFormat类,Calendar类

    BigInteger类 发 package cn.itcast_01; import java.math.BigInteger; /* * BigInteger:可以让超过Integer范围内的数据进 ...

随机推荐

  1. python学习第一天

    编码:encode 解码:decode 计算长度:len list:索引从0开始 -1可以索引最后一个元素 append添加元素 insert插入元素 pop删除末尾元素 替换的话直接赋值 list里 ...

  2. POJ 1466

    #include<iostream> #include<stdio.h> #define MAXN 505 using namespace std; int edge[MAXN ...

  3. Centos 6.5安装python3.5.1

    查看python的版本 #python  -V Python 2.6.6 1.下载Python-3.5.1 #wget https://www.python.org/ftp/python/3.5.1/ ...

  4. APACHE 与IIS同时存在的情况下,给APACHE添加反向代理 共用80端口

    一.首先打开IIS,将IIS的端口改成81,不要让IIS占用了80端口 二.打开APACHE的httpd.conf配置文件,将里面的端口配置成80 三.打开APACHE的虚拟目录配置文件,如:http ...

  5. Web性能优化系列

    web性能优化之重要,这里并不打算赘述.本系列课程将带领大家认识.熟悉.深刻体会并且懂得如果去为不同的站点做性能优化 同时,本系列将还会穿插浏览器兼容性相关问题的解决方案,因为在我看来,兼容性同样属于 ...

  6. Delphi 实现任务栏多窗口图标显示

    uses Windows; type TfrmLogin = class(TForm) end; implementation {$R *.dfm} procedure TfrmLogin.FormC ...

  7. SQL SERVER 内存分配及常见内存问题(2)——DMV查询

    原文:SQL SERVER 内存分配及常见内存问题(2)--DMV查询 内存动态管理视图(DMV): 从sys.dm_os_memory_clerks开始. SELECT [type] , SUM(v ...

  8. C语言检查ip是否合法

    在工作当中我们经常会遇到这种问题:判断一个输入的字符串是否为合法的IP地址,下面是一个测试小程序: #include <stdio.h> #include <string.h> ...

  9. python3 tkinter添加图片和文本

    在前面一篇文章基础上,使用tkinter添加图片和文本.在开始之前,我们需要安装Pillow图片库. 一.Pillow的安装 1.方法一:需要下载exe文件,根据下面图片下载和安装       下载完 ...

  10. 【LOJ#6281】数列分块5

    题目大意:维护一个有 N 个数组成的序列,支持查询区间元素和.区间元素向下取整的开方操作. 题解:由于序列中维护的数最大不超过整数的范围,而对于整数范围内的数来说,一个数在开方 5 次及以上时,结果不 ...