法律偏偏看就三长达,你就算知了卿究竟适不称创业。

发布时间:2018-11-13  栏目:法律  评论:0 Comments

同样、什么是 Java 技术?为何用 Java?

  Java 是由 Sun Microsystems 在 1995
年首先揭晓之编程语言和计算平台。有好多应用程序和 Web 站点只有当安装 Java
后才能够正常干活,而且这么的应用程序和 Web 站点逐步增多。Java
快速、安全、可靠。从笔记本电脑到数基本,从游戏操纵高到科学超级计算机,从手机及互联网,Java
无处不在!

法律 1

  Java是千篇一律种植计算机编程语言,拥有过平台、面向对象、泛型编程的性状,广泛应用于企业级Web应用开发和移动使用开发。

  任职于太阳微系统的詹姆斯·高斯林等人口让1990年间初出Java语言的雏形,最初给命名也Oak,目标设置在家电等微型系的程序语言,应用在电视机、电话、闹钟、烤面包机等小家电的主宰和通信。由于这些智能化家电的市场需求没有预想的赛,Sun公司放弃了该项计划。随着1990年代互联网的迈入,Sun公司看见Oak在互联网上运用的前景,于是改造了Oak,于1995年5月以Java的名称正式发表。Java伴随在互联网的迅猛发展而进步,逐渐变成首要的网编程语言。

  Java编程语言的品格很看似C++语言。继承了C++语言面向对象技术之中心,Java舍弃了C++语言中爱招惹错误的指针,改坐引用替换,同时移除原C++与原本运算符重载,也移除多再次继承特性,改用接口替换,增加垃圾回收器功能。在Java
SE
1.5本子中引入了泛型编程、类型安全的枚举、不定长参数与自行装/拆箱特性。太阳微系统对Java语言的解说是:“Java编程语言是只简易、面向对象、分布式、解释性、健壮、安全以及系统无关、可移栽、高性能、多线程和动态的语言”

  Java不同于一般的编译语言还是直译语言。它首先以源代码编译成字节码,然后因各种不同平台及之虚拟机来解释施行字节码,从而实现了“一坏编写,到处运行”的跨平台特性。在前期JVM中,这当得水平及落了Java程序的运转效率。但每当J2SE1.4.2颁发后,Java的运作速度发出了大幅升级。

 

工作要创业?答案自然是殊的人数来两样的选取,但是就不是可行的应,因为其拉不了自己,我一直希望在自家开另外决定的时节,都发出一个总人口一直拉自己办好了选,就如每天中午,我以逐个饭店前纠结的当儿,有只戴在墨镜,头发梳着一丝不苟,身着干净正装的丈夫当自家身后,突然一手搭在自身肩膀。

第二、语言特色

Java用被出,是若上以下五个目的:

  • 有道是以面向对象程序设计方法学
  • 应该允许同一程序在不同的处理器平台实施
  • 该包括内建的对准计算机网络的支撑
  • 当吃设计成平安地履远端代码
  • 有道是易于使,并借鉴以前那些面向对象语言(如C++)的长处。

Java技术主要分为几个部分:Java语言、Java运行环境、类库。一般景象下说Java时并无区分指的凡谁部分。

Java以1.5版本时,做了主要变更,太阳公司并1.5本更命名为Java 5.0。

面向对象

  Java的特性有就是是面向对象,是先后设计方的一样种植。“面向对象程序设计语言”的中坚之一即是开发者在计划软件的时候可以以自定义之花色和涉及操作。代码和数码的莫过于集合体叫做“对象”。一个对象可以想象成绑定了许多“行为(代码)”和“状态(数据)”的物体。对于数据结构的更改需要与代码进行通信然后操作,反之亦然。面向对象设计于大型软件工程的计划同计划性变得重爱管理,能增强工程的健康过,减少失败工程的数量。

超越平台性

  Java语言的老二单特点就是是跨平台性,也就是说使用Java语言编写的程序可以当编译后无用经过任何移,就可知以其他硬件设备条件下运作。这个特性经常给名“一差编译,到处运行”。

  执行Java应用程序必须装Java Runtime
Environment
JRE),JRE内部有一个Java虚拟机(Java Virtual
Machine,JVM)以及部分业内的类库(Class
Library)。通过JVM才会于电脑系统执行Java应用程序(Java
Application),这与.Net
Framework的情景一致,所以电脑及没有设置JVM,那么这些程序用不可知实践。

  实现跨平台性的不二法门是大多数编译器在拓展Java语言程序的编码时候会扭转一个用字节码写成的“半成品”,这个“半成品”会当Java虚拟机(解释层)的援下运作,虚拟机会将它们换成为当下所处硬件平台的原始代码。之后,Java虚拟机会打开标准库,进行数量(图片、线程和网)的造访工作。主要注意的凡,尽管就存在一个展开代码翻译的解释层,有些上Java的配节码代码还是会给JIT编译器进行次不行编译。

  有些编译器,比如GCJ,可以自动生成原始代码而休欲解释层。但是这些编译器所生成的代码只能用叫特定平台。并且GCJ目前止支持有底Java
API。

  甲骨文公司对此Java的批准是“全兼容的”,这为导致了微软与升阳关于微软的程序不支持RMI和JNI接口、并且多风味也自己所用之法网纠纷。升阳最终获了官司,获得了大概两千万美元的赔付,法院强制要求微软执行升阳公司关于Java的许可要求。作为回答,微软不再以Windows系统中捆绑Java,最新的Windows版本,Windows
Vista和Internet Explorer
7.0版也不再提供对Java应用程序和控件的支撑。但是升阳公司以及其他以Java运行时系统的店铺在Windows操作系统下对用户提供义务的老三正值插件与顺序支持。

  Java语言使用解释层最初是为轻巧性。所以这些程序的运转效率比C语言和C++要低多,用户为本着这个颇有微词。很多以来的查证显示Java的程序运行速度比较几年前使后来居上起多,有些同样效果的顺序的效率甚至超越了C++和C语言编写的先后。

  Java语言在无比开头运用的当儿是从未说明层的,所有需要编译的代码都一直换成机器的原始代码。这样做的究竟就是是沾了最佳的性能,但是程序臃肿异常。从JIT技术开始,Java的主次还经过同次等变后才改为机器码。很多名的老三方虚拟机都采用相同种叫做“动态编译”的技巧,也就是说虚拟机实时监测及分析程序的运作行为,同时选择性地指向先后所欲的有的进行编译和优化。所有这些技术还精益求精了代码的周转速度,但是还要未会见被程序的体积变得语无伦次。

  程序的轻便性事实上是软件编写好为难上的一个对象,Java虽然打响地落实了“一坏编译,到处运行”,但是出于平台和平台之间的歧异,所编写的顺序于换代码的下不免会面世轻微的、不可察觉的缪与奇怪。有些程序员对这个非常头疼,他们嘲笑Java的次序不是“一赖编译,到处运行”,而是“一潮编译,到处调试”。以Java
AWT为条例,早期Java
AWT内提供的按钮、文字区等全都是为电脑系统所默认的体而显。这令Java程序于稍微没提供美术的电脑系统产生错误(在Microsoft
Windows设有窗口管理器,在有的Linux
distribution则无)。后来SUN公司针对Java AWT一些题材设生产Java Swing。

  平台无关性让Java在劳务器端软件领域非常成功。很多劳动器端软件都以Java或有关技能建立。

电动垃圾回收(Garbage Collection)

  C++语言被用户诟病的故有是多数C++编译器不支持垃圾收集体制。通常采用C++编程的时,程序员于序中初始化对象时,会在主机内存堆栈上分红一块内存和地点,当不欲者目标时,进行析构或者去的时节再自由分配的内存地址。如果目标是于库上分红的,而程序员又忘记进行删除,那么就是见面导致内存泄漏(Memory
Leak)。长此以往,程序运行的上或会见转移很多休拔除的污染源,浪费了无必要之内存空间。而且只要一致内存地址被删除两赖的语,程序会换得无安静,甚至崩溃。因此产生更的C++程序员都见面以剔除后以指针重置为NULL,然后于去之前先行判断指针是否为NULL。

  C++中呢得使“智能指针”(Smart
Pointer)或者应用C++托管扩展编译器的法门来实现自动化内存释放,智能指针可以在业内类库中找到,而C++托管扩展为微软的Visual
C++
7.0同以上版本所支撑。智能指针的独到之处是未需要引入慢的废物收集体制,而且得免考虑线程安全的题材,但是缺点是要是不成使用智能指针的语,性能有或未设垃圾收集体制,而且不停地分配和刑满释放内存可能造成内存碎片,需要手动对堆放进行压缩。除此之外,由于智能指针是一个基于模板的职能,所以无更的程序员在用采取多态特性开展自动清理时为或束手无策。

  Java语言尽管如此不同,上述的状况为机关垃圾收集成效自动处理。对象的始建与停放都是当内存堆栈上面进行的。当一个对象没其他引用的时节,Java的机动垃圾收集体制就算发挥作用,自动删除这个目标所占用的半空中,释放内存以避免内存泄漏。

  注意程序员不欲修改finalize方法,自动垃圾收集也会产生作用。但是内存泄漏并无是就以此避免了,当程序员疏忽大意地忘记解除一个目标非应有的引用时,内存泄漏仍然不可避免。

  不同厂商、不同版本的JVM中的内存垃圾回收机制并无了一样,通常更新本子的内存回收机制进一步快,IBM、BEA、SUN等等开发JVM的小卖部还已声明过自己打出了世道上极度抢的JVM,JVM性能的世界纪录也于不断的让打破并增强。

  IBM有雷同篇有关Java内存回收机制比不激活垃圾收集体制的C++内存处理快数加倍之技能文章,而名噪一时的Java技术书籍《Java编程思想》(Thinking
in Java
)也起同等段落论述Java内存及性能及甚至超越C++的回。

 

“左手边第二家客栈,点辣椒肉丝盖浇饭,不要问怎么。”

三、环境

Java的老三种技术架构:

JAVAEE:Java Platform Enterprise
Edition,开发公司环境下的应用程序,主要对web程序开发;

JAVASE:Java Platform Standard
Edition,完成桌面应用程序的开销,是外两者的底蕴;

JAVAME:Java Platform Micro
Edition,开发电子消费产品及嵌入式设备,如手机遭到之程序;

 

JDK下载地址:http://www.oracle.com/technetwork/cn/java/javase/downloads/jdk7-downloads-1880260.html

1,JDK:Java Development
Kit,
java的开发暨周转环境,java的开发工具和jre。

2,JRE:Java Runtime
Environment,
java程序的运作环境,java运行的所要的类库+JVM(java虚拟机)。

 

java运行分点儿步:一个凡是编译,一个凡是运行。

    javac:担负的凡编译的一些,当尽javac时,会启动java的编译器程序。对点名扩展名的.java文件进行编译。
生成了jvm可以辨别的字节码文件。也即是class文件,也就是java的周转程序。

    java:荷运作的片段.会启动jvm.加载运行时所待的类库,并对class文件进行执行.

    一个文件要叫实施,必须使发出一个实施的起始点,这个起始点就是main函数.

javac HelloWorld.java
java HelloWorld.class

 

.class文件要分为两局部:

  • 常量池:    类名,成员变量名和措施引用
  • 术字节码:  各个艺术的字节码 

运作 java程序的运行过程有三三两两独号:

  • 加载
    即类的.class字节码被加载到内存中,一般第一次于用的时光才见面加载(惰性加载),这时候会为每个
    类创建一个Class对象。
  • 初始化
    由而分为静态初始化和一般初始化,静态初始化在类似加载时得,一般静态初始化自会在Class对象首
    次加载的时光进行相同不良,当创建一个目标时,首先会于积上分红足够的积存空间,这时候这块存储空间会为清零,
    即对象被的具有骨干数据列且见面于设置成0,然后再实施字段定义处的初始化动作,最后执行构造器。

 

自身的上,这时候我莫会见望而生畏,反而会高兴死的,我想我之每个决定还见面有人如此粗暴的对准本身那多好什么,别想歪了哈。

四、HelloWorld

public class HelloWorld 
{
    public static void main(String[] args) 
    {
        System.out.println("Hello, World!");
    }
}

 

而,我明白这是休可能的。但是自己有好之绝招。

五、基本数据类

4类8种:

1> 逻辑型 — boolean

2> 文本型 — char

3> 整数型 — byte, short, int, long

4> 浮点数型 — float, double

类型 占用存储空间/字节 表数范围
boolean 1/8 true & false
char 2 存储Unicode码,单引号赋值
byte 1 -128 ~ 127
short 2 -2**15 ~ 2**15-1
int 4 -2**31 ~ 2**31-1
long 8 -2**63 ~ 2**63-1
float 4 -3.403E38 ~ 3.403E38
double 8 -1.798E308 ~ 1.798E308

float 与 double 的区别:

  float表示仅精度浮点数,32位二迈入制描述;

  double表示对精度浮点数,64各项二进制表示;

  double精度高,有效数字16员,float精度7位。但double消耗内存是float的鲜倍,double的演算速度比float慢得多。

大部分底人且会会认为,一个人数是匪能够与融洽“锤子剪刀布”的。

♥常量

实数常量默认为 double;

平头常量默认为 int。

0x 和 10  内存中没分。

  1>
十六进制整型常量:以十六进制表示常常,需以0x或0X开头,如0xff,0X9A。

  2> 八迈入制整型常量:八进制必须以0开头,如0123,034。

  3> 长整型:长整型必须以L作最后,如9L,342L。

  4>
浮点数常量:由于小数常量的默认类型是double型,所以float类型的末尾必然要是加f(F)。同样带来小数的变量默认为double类型。如:f=1.3f;

  5>
字符常量:字符型常量需用单薄独单引号括起来(注意字符串常量是因此少单对引号括起来)。

Java中的字符占少数独字节。一些常用之转义字符:

  1> \r表示接受键盘输入,相当给按照下了转车键;

  2> \n表示换行;

  3> \t表示制表符,相当给Table键;

  4> \b表示退格键,相当于Back Space键;

  5> \’表示单引号;

  6> \”代表对引号;

  7> \\代表一个斜杠\。

然,今天自己报告您,这就是是当瞎扯。你可想像就这样平等客情景,早上您从床后,不知早饭吃个“小粑”好,还是同笼罩小笼包好。

 ♥基本数据类型转换

1> boolean 类型不得以换为另外的数据类型。

2> 容量小之档次自动转换为容量非常的数据类型(指代表值得范围大小):

        byte, short, char –> int –> long –> float –> double

    byte, short, char 之间不会互相转换,他们三者在计算时先会转换为 int 类型

3>
容量大之数据类型转换为容量小的数据类型时,要添加强制转换符,可能会见导致精度降低或溢出。

4>
有多种类型的多少混合运算时,系统第一自动的拿装有数据类型转换成为容量最老之那无异种植多少类,然后再进行测算。

c 语言之所以不可知移植,是盖不同体系编译后底类别长度不等同

    byte b;
    b = 1;
    int i=b;        // 1
    long l=b;       // 1
    float f=b;      // 1.0
    double d=b;     // 1.0    

// 如果低级类型为char型,向高级类型(整型)转换时,会转换为对应ASCII码值,例:
    char c='c';
    int i=c;        // 99

//对于byte,short,char三种类型而言,他们是平级的,因此不能相互自动转换,可以使用下述的强制类型转换。
    short i=99;
    char c=(char)i;    //c

// float 类型的两种方式
// 在内存中的形式是不一样的
    float f1=0.1f;             // 在内存中是float类型
    float f2=(float)(0.1);     // 在内存中是double类型,强制转换为float类型

// long类型
    long l1=123456;
    long l2=8888888888;        // 错误!!!
    long l3=8888888888L;       // 后面加L

// byte 类型
    byte b1=1;
    byte b2=2; 
    byte b3=129;    // 错误!!!超过最大值

 

此刻,你一旦告诉要好左手赢了吃“小粑”,右手赢了吃“小笼包”,记住2秒内必将要做出决定。放心,你绝对会出个结实。

六、运算符

1> 算数运算符

  +、 -、 *、 /、 %、 ++、 —

2> 赋值运算符

  =、 +=、 -=、 *=、 /=、 %=

3> 关系运算符

  >、 <、 >=、 <=、 ==、 !=

4> 逻辑运算符

  !、 ^、 &、 &&、 |、 ||

    除了 !(逻辑非) 都是用来连接两只 boolean 类型表达式

    &(逻辑与): 只生些许限还为 true 结果是 true, 否则 false;

    &&(短路与): 和 & 一样,但只要左边为 false,右边便不介入运算;

    |(逻辑或): 只发个别边都也 flase 结果是 false, 否则是 true;

    ||(短路或): 和 | 一样,但若左边为 true, 右边就非参与运算;

    ^(逻辑异): 两边结果同样吗 false, 两度结果未平等吧 true;

5> 位运算符

  &、 |、 ^、 ~、 >>、 <<、 >>>

 

法律 2法律 3

// 自加自减练习
// ++、--   在前面是先加减后赋值,在后面是先赋值在加减
        int i1 = 10;
    int i2 = 20;
    int i = i2++;
    System.out.println("i:" + i);    //20,是先赋值在自加!
    System.out.println("i2:" + i2);    //21
    i = ++i2;
    System.out.println("i:" + i);    //22
    System.out.println("i2:" + i2);    //22
    i = --i1;
    System.out.println("i:" + i);    //9
    System.out.println("i1:" + i1);    //9
    i = i1--;
    System.out.println("i:" + i);    //9
    System.out.println("i1:" + i1);    //8

自加自减练习

法律 4法律 5

    // 逻辑运算符练习
    boolean a, b, c;
    a = true; b=false;
    c = !a;        System.out.println(c);    //false
    c = a ^ b;     System.out.println(c);    //true
    c = a & b;     System.out.println(c);    //false
    c = a && b; System.out.println(c);    //false
    c = a | b;     System.out.println(c);    //true
    c = a || b; System.out.println(c);    //true

逻辑运算符练习

 

既,技巧让受您了,你可做决定了。如果您道,这样做出决定是当太草率了,其实不草率,关键是得看君实在发生没来善创业之预备。

七、基本语句

1> for 循环

    for(初始化表达式;判断表达式;递增(递减)表达式){
        执行语句;
    }

    •   初始化表达式:初始化表达式的意思,在于定义循环之前变量的价是聊。
    •   判断表达式:判断表达式的意在于规定循环的顶峰。
    •   递增(递减)表达式:这同样码规定每执行同样次等程序,变量以多少增量要减量进行转变。

2>  foreach 循环或者、加强型循环

            for(类型 变量 : 数组){
        执行语句;
    }

            JDK 1.5 引进了一如既往种植新的循环类型,被叫做 foreach
循环或者加强型循环,它会以无采用下标的情下一切历数组。

3> while 循环

    while (条件){
        操作;
    }

4> do while 循环语句子

    do/while 语句与 while
语词不同之是,在认清标准之前,先实行大括号内之循环体。

5> switch 语句

    switch (key) {
    case value:

      …
      break;

    default:

      …
      break;
    }

    •   使用 break 语句,避免 case 穿透;
    •   多只 case key 合并到一块;
    •   default 可以概括,
      也为写在自由位置,如果拿default语句放在了第一实施,则无论value是否配合,程序会从default开始实施直到第一单break出现;
    •   java 中的 switch 支持之类别可以为 byte,char,short,int
      中的同样种,JDK版本也1.7跟以上支持String。

6> break & continue

    跳出整个循环和跳出本次巡回。

7> 三处女运算

    布尔表达式?值一:值二

    布尔表达式为true结果也价值一,表达式为false结果吗值二

    java三首届表达式有字符强转的机能,会拿后面的强转为和前的种类一样

  •     如果面前是int型 会把后面字符变成对应之ascii码。
  •     如果面前是char型 会把后面数字转换成相应的字 

 

法律 6法律 7

public class OneHundredAnd{
    public static void main(String[] args){
        int result=0;
        for(int i=1;i<=100;i++){
            result+=i;
        }
        System.out.println(result);
    }
}

for 循环,
计算1+2+3+4……+100的结果

法律 8法律 9

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

foreach 循环

法律 10法律 11

public class OneHundredAnd{
    public static void main(String[] args){
        int a=1,result=0;
        while(a<=100){
            result+=a++;
        }
        System.out.println(result);
    }
}

while 循环,
计算1+2+3+4……+100的结果

法律 12法律 13

public class OneHundredAnd{
    public static void main(String[] args){
        int a=1,result=0;
        do{
            result+=a++;
        }while(a<=100);
        System.out.println(result);
    }
}

do while 循环,
计算1+2+3+4……+100的结果

法律 14法律 15

public class PrimeNumbers{
    public static void main(String[] args){
        // 输出100~200内的质数
        // 只有1和它本身这两个因数的自然数叫做质数.还可以说成质数只有1和它本身两个约数.
        // 素数是这样的整数,它除了能表示为它自己和1的乘积以外,不能表示为任 何其它两个整数的乘积.
        // 例如: 12 =6×2=4×3,所以12不是素数.

        for (int i=101; i<200; i+=2){
            for (int n=2; n<i; n++){
                if (i % n != 0){
                    System.out.println(i);
                    break;
                }
            }
        }
    }
}

输出100~200外之质数

法律 16法律 17

public class DataConversion {
    public static void main(String[] args){
        switch (18) {
        case 18:
            System.out.print("I'm eighteen years old, fighting.");
            break;
        case 19:
        case 20:
        case 21:
        case 22:
            System.out.print("I'm twenty years old, fighting.");
            break;
        default:
            System.out.print("Grow up to go away ^.^.");
            break;
        }
    }
}

case 语句 practice

法律 18法律 19

public class SimpleUnary{
 public static void main(String[] args) {
   char a = 'a';
   int b = 8;

   System.out.println(false?a:b); //打印b,b是8,所以打印出8
   System.out.println(false?a:8); //打印8,但a是char型的,所以打印8的char字 //符,也就是backspace
   System.out.println(false?8:a); //打印int型,也就是a
   System.out.println(false?b:'a'); //打印a的ASCII码

 }
}

三元运算 practice

 

接通下,就是本身总出底老三久判断,小伙伴可以团结比下。

八、Number 类

具备的包装类(Integer、Long、Byte、Double、Float、Short)还是空虚类
Number 的子类。

 

序号 方法与描述
1 xxxValue()     将number对象转换为xxx数据类型的值并返回。
2 compareTo()  将number对象与参数比较。
3 equals()     判断number对象是否与参数相等。
4 valueOf()   返回一个 Number 对象指定的内置数据类型
5 toString()   以字符串形式返回值。
6 parseInt()  将字符串解析为int类型。
7 abs()    返回参数的绝对值。
8 ceil()    对整形变量向左取整,返回类型为double型。
9 floor()   对整型变量向右取整。返回类型为double类型。
10 rint()    返回与参数最接近的整数。返回类型为double。
11 round()  返回一个最接近的int、long型值。
12 min()   返回两个参数中的最小值。
13 max()   返回两个参数中的最大值。
14 exp()    返回自然数底数e的参数次方。
15 log()     返回参数的自然数底数的对数值。
16 pow()   返回第一个参数的第二个参数次方。
17 sqrt()   求参数的算术平方根。
18 sin()     求指定double类型参数的正弦值。
19 cos()    求指定double类型参数的余弦值。
20 tan()    求指定double类型参数的正切值。
21 asin()   求指定double类型参数的反正弦值。
22 acos()   求指定double类型参数的反余弦值。
23 atan()  求指定double类型参数的反正切值。
24 atan2()  将笛卡尔坐标转换为极坐标,并返回极坐标的角度值。
25 toDegrees()  将参数转化为角度。
26 toRadians()  将角度转换为弧度。
27 random()     返回一个随机数。

 

法律 20法律 21

public class Numbers {
    public static String getType(Object o){
        return o.getClass().toString();
    }
    public static void main(String[] args){
//        // xxxValue() 将number对象转换为xxx数据类型的值并返回。
//        Integer i1=1;
//        float f1 = i1.floatValue();
//        System.out.println(f1 + " " + getType(f1));    //1.0 class java.lang.Float
//        int f2 = i1.intValue();
//        System.out.println(f2 + " " + getType(f2));    //1 class java.lang.Integer
//        byte f3 = i1.byteValue();
//        System.out.println(f3 + " " + getType(f3));    //1 class java.lang.Byte
////        i1.compareTo(1);

//        // 比较这个Number对象的参数. 一样返回0,否则-1.
//        Integer i1=1;
//        int i2 = i1.compareTo(1);
//        System.out.println(i2);

//        // 确定这个数字对象是否等于参数.一样返回true,否则false.
//        Integer i1=1;
//        byte i2=1;
//        boolean i3 = i1.equals(i2);
//        System.out.println(i3);    //false

//        //返回一个 Number 对象指定的内置数据类型
//        //nteger.valueOf()方法基于减少对象创建次数和节省内存的考虑,
//        //缓存了[-128,127]之间的数字。此数字范围内传参则直接返回缓存中的对象。
//        Integer i1=1;
//        Integer i2 = Integer.valueOf(i1);
//        System.out.println(i2);    //1

//        //以字符串形式返回值。
//        Integer i1=1;
//        String i2 = i1.toString();
//        System.out.println(i2);    //1

//        //将字符串解析为int类型。
//        String i1="9";
//        Integer i2 = Integer.parseInt(i1);
//        System.out.println(i2);    //9

//        //返回参数的绝对值。
//        Integer i1=-1;
//        Integer i2 = Math.abs(i1);
//        System.out.println(i2);    //1

//        //对整形变量向左取整,返回类型为double型。
//        int i1=1;
//        double i2 = Math.ceil(i1);
//        System.out.println(i2);    //1.0

//        //对整型变量向右取整。返回类型为double类型。
//        int i1=1;
//        double i2 = Math.floor(i1);
//        System.out.println(i2);    //1.0

//        //返回与参数最接近的整数。返回类型为double。
//        double i1=1.623;
//        double i2 = Math.rint(i1);
//        System.out.println(i2);    //2.0

//        //返回一个最接近的int、long型值。
//        double i1=1.623;
//        long i2 = Math.round(i1);
//        System.out.println(i2);    //2

//        //返回两个参数中的最小值。
//        double i1=1.6;
//        double i2=1.8;
//        double i3 = Math.min(i1, i2);
//        System.out.println(i3);    //1.6

//        //返回两个参数中的最大值。
//        int i1=9;
//        int i2=5;
//        int i3 = Math.max(i1, i2);
//        System.out.println(i3);    //9

//        //返回两个参数中的最大值。
//        int i1=9;
//        int i2=5;
//        int i3 = Math.max(i1, i2);
//        System.out.println(i3);    //9

//        //返回自然数底数e的参数次方。
//        double i1=9;
//        double i2 = Math.exp(i1);
//        System.out.println(i2);    //8103.083927575384

//        //返回参数的自然数底数的对数值。
//        double i1=9;
//        double i2 = Math.log(i1);
//        System.out.println(i2); //2.1972245773362196

//        //返回第一个参数的第二个参数次方。2的3次方.
//        double i1=2;
//        double i2=3;
//        double i3 = Math.pow(i1, i2);
//        System.out.println(i3);    //8.0

//        //求参数的算术平方根。
//        double i1=9;
//        double i2 = Math.sqrt(i1);
//        System.out.println(i2);    //3.0

//        //求指定double类型参数的正弦值。
//        double i1=3;
//        double i2 = Math.sin(i1);
//        System.out.println(i2);    //3.0

//        //求指定double类型参数的余弦值。
//        double i1=3;
//        double i2 = Math.cos(i1);
//        System.out.println(i2);    //-0.9899924966004454

//        //求指定double类型参数的正切值。
//        double i1=3;
//        double i2 = Math.tan(i1);
//        System.out.println(i2);    //-0.1425465430742778

//        //求指定double类型参数的反正弦值。NaN
//        double i1=1;
//        double i2 = Math.asin(i1);
//        System.out.println(i2);    //1.5707963267948966

//        //求指定double类型参数的反余弦值。NaN
//        double i1=2;
//        double i2 = Math.acos(i1);
//        System.out.println(i2);    //0.0

//        //求指定double类型参数的反正切值。
//        double i1=3;
//        double i2 = Math.atan(i1);
//        System.out.println(i2);    //1.2490457723982544

//        //将笛卡尔坐标转换为极坐标,并返回极坐标的角度值。
//        double i1=3;
//        double i2=3;
//        double i3 = Math.atan2(i1, i2);
//        System.out.println(i3); //0.7853981633974483

//        //将参数转化为角度。
//        double i1=3;
//        double i2 = Math.toDegrees(i1);
//        System.out.println(i2);    //171.88733853924697

//        //将角度转换为弧度。
//        double i1=3;
//        double i2 = Math.toRadians(i1);
//        System.out.println(i2);    //0.05235987755982988

//        //返回一个随机数。
//        double i1 = Math.random();
//        System.out.println(i1);    //0.9591935059236623

    }
}

Number practice

 

相同:创业你见面对什么?

九、Character 类

Character 类用于对单个字符进行操作。

Character 类在对象吃封装一个中坚项目 char 的值

 

序号 方法与描述
1 isLetter() 是否是一个字母
2 isDigit()   是否是一个数字字符
3 isWhitespace() 是否是一个空格
4 isUpperCase()  是否是大写字母
5 isLowerCase()  是否是小写字母
6 toUpperCase()  指定字母的大写形式
7 toLowerCase()  指定字母的小写形式
8 toString()  返回字符的字符串形式,字符串的长度仅为1

 

法律 22法律 23

public class Characters {
    public static void main(String[] args){
        char c1 = 'm';

//        //是否是一个字母
//        boolean b1 = Character.isLetter(c1);
//        System.out.println(b1);    //true

//        //是否是一个数字字符
//        boolean b1 = Character.isDigit(c1);
//        System.out.println(b1);    //false

//        //是否是一个空格
//        boolean b1 = Character.isWhitespace(c1);
//        System.out.println(b1);    //false

//        //是否是大写字母
//        boolean b1 = Character.isUpperCase(c1);
//        System.out.println(b1);    //false

//        //是否是小写字母
//        boolean b1 = Character.isLowerCase(c1);
//        System.out.println(b1);    //true

//        //指定字母的大写形式,变大写
//        char b1 = Character.toUpperCase(c1);
//        System.out.println(b1);    //M

//        //指定字母的小写形式,变小写
//        char b1 = Character.toLowerCase(c1);
//        System.out.println(b1);    //m

//        //返回字符的字符串形式,字符串的长度仅为1
//        String b1 = Character.toString(c1);
//        System.out.println(b1);    //m
    }    
}

Character practice

 

成千上万总人口,尤其是部分发声着如创业之小伙,其实她们确实没有办好其他的备。

十、String 类

以主要字和构造方法来创造 String 对象。

String 类是不可改变的,所以您只要创立了 String
对象,那它的值就是无法转移了(如果要对字符串做多改,那么当选择下 StringBuffer
& StringBuilder 类)

String 类有 11
种构造方法,这些艺术供不同之参数来初始化字符串,比如提供一个字符数组参数:

public class StringDemo{
   public static void main(String args[]){
      char[] hello = { 's', 'u', 'o', 'n', 'i', 'n', 'g'};
      String hellos = new String(hello);  
      System.out.println( hellos );
   }
}

法律 24法律 25

String() 
          初始化一个新创建的 String 对象,它表示一个空字符序列。 
String(byte[] bytes) 
          构造一个新的 String,方法是使用平台的默认字符集解码字节的指定数组。 
String(byte[] ascii, int hibyte) 
          已过时。 该方法无法将字节正确转换为字符。从 JDK 1.1 起,完成该转换的首选方法是通过 String 构造方法,该方法接受一个字符集名称或使用平台的默认字符集。 
String(byte[] bytes, int offset, int length) 
          构造一个新的 String,方法是使用指定的字符集解码字节的指定子数组。 
String(byte[] ascii, int hibyte, int offset, int count) 
          已过时。 该方法无法将字节正确转换为字符。从 JDK 1.1 开始,完成该转换的首选方法是通过 String 构造方法,它接受一个字符集名称,或者使用平台默认的字符集。 
String(byte[] bytes, int offset, int length, String charsetName) 
          构造一个新的 String,方法是使用指定的字符集解码字节的指定子数组。 
String(byte[] bytes, String charsetName) 
          构造一个新的 String,方法是使用指定的字符集解码指定的字节数组。 
String(char[] value) 
          分配一个新的 String,它表示当前字符数组参数中包含的字符序列。 
String(char[] value, int offset, int count) 
          分配一个新的 String,它包含来自该字符数组参数的一个子数组的字符。 
String(int[] codePoints, int offset, int count) 
          分配一个新的 String,它包含该 Unicode 代码点数组参数的一个子数组的字符。 
String(String original) 
          初始化一个新创建的 String 对象,表示一个与该参数相同的字符序列;换句话说,新创建的字符串是该参数字符串的一个副本。 
String(StringBuffer buffer) 
          分配一个新的字符串,它包含当前包含在字符串缓冲区参数中的字符序列。

String 类 11 种构造方法

 

序号 方法描述
1 char charAt(int index)
返回指定索引处的 char 值。
2 int compareTo(Object o)
把这个字符串和另一个对象比较。
3 int compareTo(String anotherString)
按字典顺序比较两个字符串。
4 int compareToIgnoreCase(String str)
按字典顺序比较两个字符串,不考虑大小写。
5 String concat(String str)
将指定字符串连接到此字符串的结尾。
6 boolean contentEquals(StringBuffer sb)
当且仅当字符串与指定的StringButter有相同顺序的字符时候返回真。
7 static String copyValueOf(char[] data)
返回指定数组中表示该字符序列的 String。
8 static String copyValueOf(char[] data, int offset, int count)
返回指定数组中表示该字符序列的 String。
9 boolean endsWith(String suffix)
测试此字符串是否以指定的后缀结束。
10 boolean equals(Object anObject)
将此字符串与指定的对象比较。
11 boolean equalsIgnoreCase(String anotherString)
将此 String 与另一个 String 比较,不考虑大小写。
12 byte[] getBytes()
 使用平台的默认字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。
13 byte[] getBytes(String charsetName)
使用指定的字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。
14 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此字符串复制到目标字符数组。
15 int hashCode()
返回此字符串的哈希码。
16 int indexOf(int ch)
返回指定字符在此字符串中第一次出现处的索引。
17 int indexOf(int ch, int fromIndex)
返回在此字符串中第一次出现指定字符处的索引,从指定的索引开始搜索。
18 int indexOf(String str)
 返回指定子字符串在此字符串中第一次出现处的索引。
19 int indexOf(String str, int fromIndex)
返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引开始。
20 String intern()
 返回字符串对象的规范化表示形式。
21 int lastIndexOf(int ch)
 返回指定字符在此字符串中最后一次出现处的索引。
22 int lastIndexOf(int ch, int fromIndex)
返回指定字符在此字符串中最后一次出现处的索引,从指定的索引处开始进行反向搜索。
23 int lastIndexOf(String str)
返回指定子字符串在此字符串中最右边出现处的索引。
24 int lastIndexOf(String str, int fromIndex)
 返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索。
25 int length()
返回此字符串的长度。
26 boolean matches(String regex)
告知此字符串是否匹配给定的正则表达式。
27 boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等。
28 boolean regionMatches(int toffset, String other, int ooffset, int len)
测试两个字符串区域是否相等。
29 String replace(char oldChar, char newChar)
返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
30 String replaceAll(String regex, String replacement
使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
31 String replaceFirst(String regex, String replacement)
 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
32 String[] split(String regex)
根据给定正则表达式的匹配拆分此字符串。
33 String[] split(String regex, int limit)
根据匹配给定的正则表达式来拆分此字符串。
34 boolean startsWith(String prefix)
测试此字符串是否以指定的前缀开始。
35 boolean startsWith(String prefix, int toffset)
测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
36 CharSequence subSequence(int beginIndex, int endIndex)
 返回一个新的字符序列,它是此序列的一个子序列。
37 String substring(int beginIndex)
返回一个新的字符串,它是此字符串的一个子字符串。
38 String substring(int beginIndex, int endIndex)
返回一个新字符串,它是此字符串的一个子字符串。
39 char[] toCharArray()
将此字符串转换为一个新的字符数组。
40 String toLowerCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
41 String toLowerCase(Locale locale)
 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写。
42 String toString()
 返回此对象本身(它已经是一个字符串!)。
43 String toUpperCase()
使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
44 String toUpperCase(Locale locale)
使用给定 Locale 的规则将此 String 中的所有字符都转换为大写。
45 String trim()
返回字符串的副本,忽略前导空白和尾部空白。
46 static String valueOf(primitive data type x)
返回给定data type类型x参数的字符串表示形式。

 

法律 26法律 27

import java.nio.charset.Charset;

import javax.print.DocFlavor.BYTE_ARRAY;


public class Strings {
    public static void main(String[] args){
        String s1 = "suoning";
        String s2 = "nick";

//        //返回指定索引处的 char 值。
//        char c1 = s1.charAt(3);
//        System.out.println(c1);    //n

//        //把这个字符串和另一个对象比较.等于返回0,此字符串小于字符串参数返回小于0,大于返回大于0.
//        int c1 = s1.compareTo(s2);
//        System.out.println(c1);    //5

//        //将指定字符串连接到此字符串的结尾。
//        String c1 = s1.concat(s2);
//        System.out.println(c1);    //suoningnick

//        //当且仅当字符串与指定的StringButter有相同顺序的字符时候返回真。
//        StringBuffer s3 = new StringBuffer("suoning");
//        boolean c1 = s1.contentEquals(s3);
//        System.out.println(c1);    //true

//        //返回指定数组中表示该字符序列的 String。
//        char[] s3 = {'s', 'u', 'o', ' ', 'n', 'i', 'n', 'g'};
//        String c1 = s1.copyValueOf(s3);
//        System.out.println(c1);    //suo ning
//        String c2 = s1.copyValueOf(s3, 1, 6);
//        System.out.println(c2);    //uo nin

//        //测试此字符串是否以指定的后缀结束。
//        boolean c1 = s1.endsWith(s2);
//        System.out.println(c1);    //false

//        //将此字符串与指定的对象比较。
//        boolean c1 = s1.equals(s2);
//        System.out.println(c1);    //false

//        //将此 String 与另一个 String 比较,不考虑大小写。
//        boolean c1 = s1.equalsIgnoreCase(s2);
//        System.out.println(c1);    //false

//        //使用平台的默认字符集将此 String 编码为 byte 序列,并将结果存储到一个新的 byte 数组中。
//        byte[] c1 = s1.getBytes();
//        System.out.println(c1);    //[B@11e78461

//        //将字符从此字符串复制到目标字符数组。
//        //srcBegin -- 字符串中要复制的第一个字符的索引。 rcEnd -- 字符串中要复制的最后一个字符之后的索引。
//        //dst -- 目标数组。 dstBegin -- 目标数组中的起始偏移量。
//        //没有返回值,但会抛出 IndexOutOfBoundsException 异常。
//        //char[] s3 = new char[5];
//        s1.getChars(1,6,s3,0);
//        System.out.println(s3);    //uonin

//        //返回此字符串的哈希码。
//        int s3 = s1.hashCode();
//        System.out.println(s3);    //-1855756159

//        //返回指定字符在此字符串中第一次出现处的索引。
//        int s3 = s1.indexOf('s');
//        System.out.println(s3);    //0
//        //返回在此字符串中第一次出现指定字符处的索引,从指定的索引开始搜索。
//        int s3 = s1.indexOf('n', 3);
//        System.out.println(s3);    //3

//        // 返回字符串对象的规范化表示形式。
//        String s3 = s1.intern();
//        System.out.println(s3);    //suoning

//        // 返回指定字符在此字符串中最后一次出现处的索引。
//        int s3 = s1.lastIndexOf('n');
//        System.out.println(s3);    //5
//        // 返回指定字符在此字符串中最后一次出现处的索引,从指定的索引处开始进行反向搜索。
//        int s3 = s1.lastIndexOf('n', 3);
//        System.out.println(s3);    //3
//        // 返回指定子字符串在此字符串中最右边出现处的索引。
//        String s4 = new String("ning");
//        int s3 = s1.lastIndexOf(s4);
//        System.out.println(s3);    //3
//        //返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索。
//        String s4 = new String("ning");
//        int s3 = s1.lastIndexOf(s4, 2);
//        System.out.println(s3);    //-1

//        //返回此字符串的长度。
//        int s3 = s1.length();
//        System.out.println(s3);    //7

//        //告知此字符串是否匹配给定的正则表达式。
//        boolean s3 = s1.matches("suo(.*)");
//        System.out.println(s3);    //true

        //测试两个字符串区域是否相等。
        //ignoreCase -- 如果为 true,则比较字符时忽略大小写。
        //toffset -- 此字符串中子区域的起始偏移量。
        //other -- 字符串参数。
        //toffset -- 字符串参数中子区域的起始偏移量。
        //len -- 要比较的字符数。
//        boolean s3 = s1.regionMatches(3, s2, 6, 4);
//        System.out.println(s3);    //false
//        boolean s3 = s1.regionMatches(true, 3, s2, 6, 4);
//        System.out.println(s3);    //false

//        //返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
//        String s3 = s1.replace(' ', 'm');
//        System.out.println(s3);    //suoning

//        //返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
//        String s3 = s1.replace(' ', 'm');
//        System.out.println(s3);    //suoning

//        // 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。
//        String s3 = s1.replaceAll(".*", "m");
//        System.out.println(s3);    //mm

//        //使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。
//        String s3 = s1.replaceFirst("n", "m");
//        System.out.println(s3);    //suoming

//        //根据给定正则表达式的匹配拆分此字符串。
//        String s5 = new String("suo ning");
//        String[] s3 = s5.split(" ", 0);
//        for (String retval: s3){
//            System.out.println(retval); //suo、ning
//        }

//        // 测试此字符串是否以指定的前缀开始。
//        boolean b1 = s1.startsWith(s2);
//        System.out.println(b1);    //false
//        //测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
//        boolean b1 = s1.startsWith(s2, 3);
//        System.out.println(b1);    //false

//        //返回一个新的字符序列,它是此序列的一个子序列。
//        String s3 = s1.substring(2, 6);
//        System.out.println(s3);    //onin

//        //返回一个新的字符序列,它是此序列的一个子序列。
//        CharSequence s3 = s1.subSequence(2, 6);
//        System.out.println(s3);    //onin

//        //返回一个新的字符序列,它是此序列的一个子字符串。
//        String s3 = s1.substring(2, 6);
//        System.out.println(s3);    //onin
//        String s3 = s1.substring(2);
//        System.out.println(s3);    //oning

//        //将此字符串转换为一个新的字符数组。
//        System.out.println(s1.toCharArray());    //suoning

//        //使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
//        String s3 = s1.toLowerCase();
//        System.out.println(s3);    //suoning

//        // 返回此对象本身(它已经是一个字符串!
//        String s3 = s1.toString();
//        System.out.println(s3);    //suoning

//        // 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
//        String s3 = s1.toUpperCase();
//        System.out.println(s3);    //SUONING

//        // 返回字符串的副本,忽略前导空白和尾部空白。
//        String s3 = s1.trim();
//        System.out.println(s3);    //suoning

//        // 返回给定data type类型x参数的字符串表示形式。
//        String s3 = String.valueOf(s1);
//        System.out.println(s3);    //suoning
    }
}

String practice

 

自家哪怕是一个典型的事例,在高中毕业选正规的时节,我就想着后不要要援助别人做事,以后要协调创业,自己开老板那才自由。

十一、StringBuffer & StringBuilder 类

当对字符串进行修改的时,需要利用 StringBuffer 和 StringBuilder 类。

暨 String 类不同之是,StringBuffer 和 StringBuilder
类的对象能够被一再之改动,并且不产生新的非利用对象。

StringBuilder 类在 Java 5 中叫提出,它同 StringBuffer 之间的极深不同在于
StringBuilder 的办法无是线程安全之(不能够共同访问)。

由于 StringBuilder 相较于 StringBuffer
有快优势,所以大部分景下建议以 StringBuilder
类。然而以应用程序要求线程安全之景况下,则必须用 StringBuffer 类。

 

序号 方法描述
1 public StringBuffer append(String s)
将指定的字符串追加到此字符序列
2 public StringBuffer reverse()
将此字符序列用其反转形式取代
3 public delete(int start, int end)
移除此序列的子字符串中的字符
4 public insert(int offset, int i)
将 int 参数的字符串表示形式插入此序列中
5 replace(int start, int end, String str)
使用给定 String 中的字符替换此序列的子字符串中的字符
6 int capacity()
返回当前容量。
7 char charAt(int index)
返回此序列中指定索引处的 char 值。
8 void ensureCapacity(int minimumCapacity)
确保容量至少等于指定的最小值。
9 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
将字符从此序列复制到目标字符数组 dst
10 int indexOf(String str)
返回第一次出现的指定子字符串在该字符串中的索引。
11 int indexOf(String str, int fromIndex)
从指定的索引处开始,返回第一次出现的指定子字符串在该字符串中的索引。
12 int lastIndexOf(String str)
返回最右边出现的指定子字符串在此字符串中的索引。
13 int lastIndexOf(String str, int fromIndex)
返回最后一次出现的指定子字符串在此字符串中的索引。
14 int length()
 返回长度(字符数)。
15 void setCharAt(int index, char ch)
将给定索引处的字符设置为 ch
16 void setLength(int newLength)
设置字符序列的长度。
17 CharSequence subSequence(int start, int end)
返回一个新的字符序列,该字符序列是此序列的子序列。
18 String substring(int start)
返回一个新的 String,它包含此字符序列当前所包含的字符子序列。
19 String substring(int start, int end)
返回一个新的 String,它包含此序列当前所包含的字符子序列。
20 String toString()
返回此序列中数据的字符串表示形式。

 

法律 28法律 29

public class StringBufferBuilders {
    public static void main(String[] args){
        StringBuffer s1 = new StringBuffer("suoning");

//        //将指定的字符串追加到此字符序列。
//        String s2 = "nick";
//        StringBuffer s3 = s1.append(s2);
//        System.out.println(s3);    //suoningnick

//        //将此字符序列用其反转形式取代。
//        StringBuffer s3 = s1.reverse();
//        System.out.println(s3);    //gninous

//        //移除此序列的子字符串中的字符。
//        StringBuffer s3 = s1.delete(0, 3);
//        System.out.println(s3);    //ning

//        //将 int 参数的字符串表示形式插入此序列中。
//        StringBuffer s3 = s1.insert(3, 99);
//        System.out.println(s3);    //suo99ning

//        //使用给定 String 中的字符替换此序列的子字符串中的字符。
//        StringBuffer s3 = s1.replace(0, 3, "nick");
//        System.out.println(s3);    //nickning


//        //返回当前容量。
//        int s3 = s1.capacity();
//        System.out.println(s3);    //23

//        //返回此序列中指定索引处的 char 值。
//        char s3 = s1.charAt(3);
//        System.out.println(s3);    //n

//        //确保容量至少等于指定的最小值。
//        s1.ensureCapacity(1);
//        System.out.println(s1.capacity());    //23

//        //将字符从此序列复制到目标字符数组 dst。
//        char[] s2 = new char[4];
//        s1.getChars(3,7,s2,0);
//        System.out.println(s2);    //ning

//        //返回第一次出现的指定子字符串在该字符串中的索引。
//        String s2 = "nick";
//        int s3 = s1.indexOf(s2);
//        System.out.println(s3);    //-1
//        //从指定的索引处开始,返回第一次出现的指定子字符串在该字符串中的索引。
//        String s2 = "nick";
//        int s3 = s1.indexOf(s2, 2);
//        System.out.println(s3);    //-1

//        //返回最右边出现的指定子字符串在此字符串中的索引。
//        String s2 = "nick";
//        int s3 = s1.lastIndexOf(s2);
//        System.out.println(s3);    //-1
//        //返回最后一次出现的指定子字符串在此字符串中的索引。
//        String s2 = "nick";
//        int s3 = s1.lastIndexOf(s2, 3);
//        System.out.println(s3);    //-1

//        // 返回长度(字符数)。
//        int s3 = s1.length();
//        System.out.println(s3);    //7

//        //将给定索引处的字符设置为 ch。
//        s1.setCharAt(3, 'm');
//        System.out.println(s1);    //suoming

//        //设置字符序列的长度
//        s1.setLength(9);
//        System.out.println(s1.length());    //9

//        //返回一个新的字符序列,该字符序列是此序列的子序列。
//        CharSequence s3 = s1.subSequence(3, 7);
//        System.out.println(s3);    //ning

//        //返回一个新的 String,它包含此字符序列当前所包含的字符子序列。
//        String s3 = s1.substring(3);
//        System.out.println(s3);    //ning
//        //返回一个新的 String,它包含此序列当前所包含的字符子序列。
//        String s3 = s1.substring(3,7);
//        System.out.println(s3);    //ning

//        //返回此序列中数据的字符串表示形式
//        String s3 = s1.toString();
//        System.out.println(s3);    //suoning

    }
}

StringBuffer & StringBuilder
practice

 

骨子里,这便是杰出没有工作更的总人口之空想。我要好就是这样想的:工作吧,没人会见让一个没什么经验的人太多之机锻炼,等到你及了迟早年纪,你不怕从未了创业的满腔热情,变成了一个老油条了,所以还是大学创业的好。这样的理由来一定量漫长。

十二、数组

Java 语言中提供的数组是因此来储存固定大小的同类型元素。

// 申明及创建数组
int a1[] = new int[6];    //不推荐写法,来源于C/C++
int[] a2 = new int[6];
int[] a3 = {1, 2, 3, 4, 5, 6};

屡次组的素是通过索引访问的。数组索引自 0 开始,所以找引值从 0 到
a2.length-1。

//多维数组
String s[][] = new String[5][9];
s[0][0] = new String("nick");
s[0][1] = new String("good");
s[1][0] = new String("jenny");
s[1][1] = new String("yep");
s[1][2] = new String("!");

法律 30法律 31

public class TestArray {
   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素
      for (int i = 0; i < myList.length; i++) {
         System.out.println(myList[i] + " ");
      }
      // 计算所有元素的总和
      double total = 0;
      for (int i = 0; i < myList.length; i++) {
         total += myList[i];
      }
      System.out.println("Total is " + total);
      // 查找最大元素
      double max = myList[0];
      for (int i = 1; i < myList.length; i++) {
         if (myList[i] > max) max = myList[i];
      }
      System.out.println("Max is " + max);
   }
}

数组 practice

 

java.util.Arrays 类能造福地操作数组,它提供的具有术还是静态的。

序号 方法和说明
1 public static int binarySearch(Object[] a, Object key)
用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) – 1)。
2 public static boolean equals(long[] a, long[] a2)
如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
3 public static void fill(int[] a, int val)
将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
4 public static void sort(Object[] a)
对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。

 

法律 32法律 33

import java.util.Arrays;


public class MyArrayOfs {
    public static void main(String[] args){
        int a1[] = new int[6];
        int[] a2 = new int[6];
        int[] a3 = {1, 2, 3, 4, 5, 6};
        int[] a5 = {1, 2, 3, 9, 8, 8};
        int[] a6 = {1, 2, 3, 4, 5, 6};


//        //    public static boolean equals(long[] a, long[] a2)
//        //如果两个指定的 long 型数组彼此相等,则返回 true。如果两个数组包含相同数量的元素,并且两个数组中的所有相应元素对都是相等的,则认为这两个数组是相等的。换句话说,如果两个数组以相同顺序包含相同的元素,则两个数组是相等的。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
//        boolean b1 = Arrays.equals(a3, a5);
//        System.out.println(b1);    //false
//        boolean b2 = Arrays.equals(a3, a6);
//        System.out.println(b2);    //true


//        //public static void fill(int[] a, int val)
//        //填充值
//        //将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
//        Arrays.fill(a2, 9);
//        System.out.println(a2[5]);    //9


//        //public static void sort(Object[] a)
//        //对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型(Byte,short,Int等)。
//        Arrays.sort(a5);
//        for(int i: a5) {
//             System.out.println(i);    //1、2、3、8、8、9
//          }


//        //public static int binarySearch(Object[] a, Object key)
//        //用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中,则返回搜索键的索引;否则返回 (-(插入点) - 1)。
//        int index1 = Arrays.binarySearch(a5, 9);
//        System.out.println(index1);  //-7
//        Arrays.sort(a5);
//        int index2 = Arrays.binarySearch(a5, 8);
//        System.out.println(index2);  //4
//        int index3 = Arrays.binarySearch(a5, 9);
//        System.out.println(index3);  //5
    }
}

数组 practice

 

1.       自由度高

十三、Date 日期时

java.util 包提供了 Date 类来封装当前之日子与时间。

# 实例化 Date 对象
import java.util.Date;

Date d1 = new Date();
long t1 = 1514736000000L;
Date d2 = new Date(t1);
System.out.println(d1);  //Mon Dec 05 23:59:59 CST 2016
System.out.println(d2);  //Mon Jan 01 00:00:00 CST 2018

Date 对象的措施:

序号 方法和描述
1 boolean after(Date date)
若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
2 boolean before(Date date)
若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
3 Object clone( )
返回此对象的副本。
4 int compareTo(Date date)
比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
5 int compareTo(Object obj)
若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
6 boolean equals(Object date)
当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
7 long getTime( )
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
8 int hashCode( )
 返回此对象的哈希码值。
9 void setTime(long time)
用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
10 String toString( )
转换Date对象为String表示形式,并返回该字符串。

 

法律 34法律 35

import java.util.Date;


public class DateTimes {
    public static void main(String[] args){
        Date d1 = new Date();
        long t1 = 1514736000000L;
        Date d2 = new Date(t1);
        System.out.println(d1);  //Mon Dec 05 23:59:59 CST 2016
        System.out.println(d2);  //Mon Jan 01 00:00:00 CST 2018


//        //    boolean after(Date date)
//        //若当调用此方法的Date对象在指定日期之前\后返回true,否则返回false。
//        boolean b1 = d2.after(d1);
//        System.out.println(b1);  //true


//        //    int compareTo(Date date)
//        //比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数
//        int b1 = d2.compareTo(d1);
//        System.out.println(b1);  //1


//        //    int compareTo(Object obj)
//        //若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
//        int b1 = d2.compareTo(d1);
//        System.out.println(b1);  //1


//        //boolean equals(Object date)
//        //当调用此方法的Date对象和指定日期相等时候返回true,否则返回false
//        boolean b1 = d2.equals(d1);
//        System.out.println(b1);  //false


//        //    long getTime( )
//        //返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
//        long l1 = d2.getTime();
//        System.out.println(l1);  //1514736000000


//        //int hashCode( )
//        //返回此对象的哈希码值。
//        long l1 = d2.hashCode();
//        System.out.println(l1);  //-1387455136


//        //void setTime(long time)
//        //用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
//        d1.setTime(t1);
//        System.out.println(d1);  //Mon Jan 01 00:00:00 CST 2018


//        //String toString( )
//        //转换Date对象为String表示形式,并返回该字符串。
//        d2.toString();
//        System.out.println(d2);  //Mon Jan 01 00:00:00 CST 2018
    }
}

Date practice

法律 36法律 37

import java.util.Date;

public class DateDemo {
   public static void main(String args[]) {
       // 初始化 Date 对象
       Date date = new Date();

       // 使用 toString() 函数显示日期时间
       System.out.println(date.toString());
   }
}

获得当前日子时

 

2.       比工作再度会效仿到博东西。

使用DateFormat 格式化日期

假使你如此想的语,我好明确的晓,在您的创业初期你会赶上什么。

日期和岁月更换字符

字符 描述 例子
c 完整的日期和时间 Mon May 04 09:51:52 CDT 2009
F ISO 8601 格式日期 2004-02-09
D U.S. 格式日期 (月/日/年) 02/09/2004
T 24小时时间 18:05:19
r 12小时时间 06:05:19 pm
R 24小时时间,不包含秒 18:05
Y 4位年份(包含前导0) 2004
y 年份后2位(包含前导0) 04
C 年份前2位(包含前导0) 20
B 月份全称 February
b 月份简称 Feb
m 2位月份(包含前导0) 02
d 2位日子(包含前导0) 03
e 2位日子(不包含前导0) 9
A 星期全称 Monday
a 星期简称 Mon
j 3位年份(包含前导0) 069
H 2位小时(包含前导0), 00 到 23 18
k 2位小时(不包含前导0),  0 到 23 18
I 2位小时(包含前导0), 01 到 12 06
l 2位小时(不包含前导0),  1 到 12 6
M 2位分钟(包含前导0) 05
S 2位秒数(包含前导0) 19
L 3位毫秒(包含前导0) 047
N 9位纳秒(包含前导0) 047000000
P 大写上下午标志 PM
p 小写上下午标志 pm
z 从GMT的RFC 822数字偏移 -0800
Z 时区 PST
s 自 1970-01-01 00:00:00 GMT的秒数 1078884319
Q 自 1970-01-01 00:00:00 GMT的毫妙 1078884319047

 

//使用两个字母格式,它以t开头并且以下面表格中的一个字母结尾。

import java.util.Date;
  public class DateTimes {
  public static void main(String args[]) {
      //初始化 Date 对象
      Date date = new Date();
      //使用toString()显示日期和时间
      String str = String.format("Current Date/Time : %tc", date );
      System.out.println(str);    //Current Date/Time : Sat Jan 1 00:00:00 MST 2018
      System.out.printf("%1$s %2$tB %2$td, %2$tY", "Due date:", date); //Jan date: January 01, 2018
      System.out.printf("%s %tB %<te, %<tY", "Due date:", date); //Jan date: January 01, 2018
  }
}

法律 38法律 39

//解析字符串为时间

import java.util.*;
import java.text.*;

public class DateTimes {
    public static void main(String args[]) {
        SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");
        String input = args.length == 0 ? "2018-01-01" : args[0];
        System.out.print(input + " Parses as ");
        Date t;
        try {
          t = ft.parse(input);
          System.out.println(t);
          } catch (ParseException e) {
          System.out.println("Unparseable using " + ft);
          //2018-01-01 Parses as Mon Jan 01 00:00:00 CST 2018
        }
    }
}

剖析字符串为日

法律 40法律 41

//Java 休眠(sleep)

import java.util.*;

public class DateTimes {
    public static void main(String args[]) {
        try {
            System.out.println(new Date( ) + "\n");
            Thread.sleep(1000*3); // 休眠3秒
            System.out.println(new Date( ) + "\n");
        } catch (Exception e) {
            System.out.println("Got an exception!");
        }
    }
}

Java 休眠(sleep)

法律 42法律 43

//检测时间间隔(以毫秒为单位)

import java.util.*;

public class DateTimes {

   public static void main(String args[]) {
      try {
         long start = System.currentTimeMillis( );
         System.out.println(new Date( ) + "\n");
         Thread.sleep(5*20*5);
         System.out.println(new Date( ) + "\n");
         long end = System.currentTimeMillis( );
         long diff = end - start;
         System.out.println("Difference is : " + diff);    //Difference is : 520
      } catch (Exception e) {
         System.out.println("Got an exception!");
      }
   }
}

检测时间间隔

 

“琐事”大量底“琐事”,如果你是独技巧男,一定都是些你难以启齿忍受的鸡毛蒜皮的末节,什么电脑坏了,有快递恢复你只要夺回,地下员工来杂事了,你如果过去帮助处理啊。账目不对了,你若错过对一下呀。

同一天下来你见面发现自己,干的都是数什么什么,尤其是部分口手少的局,几月份下来,新物是从来不怎么套到,倒是有零星的技术,自己是样样精通。

免迷信的话语我举两独例证,

俞敏洪于开立新东方初期干的顶多的同等件是啊事?备课?背单词,不是,就是骑在个自行车漫天的错过贴小广告。

常放俞先生的演讲小伙伴,你得十分易之追忆起俞先生口中这段艰辛的广告史。

还有一个哪怕是“得到”,也是“罗辑思维”公司的技艺总监-快刀青衣。脱不消费就是在马上周的例会中说了不久刀青衣的故事。

立刻快刀青衣在参加“罗辑思维”的时,也是同下创业企业之创始人。但是,脱不花费,罗胖就径直想拉快刀青衣入伙,但是对于快刀青衣来说,自己辛辛苦苦打下的国度,凭什么虽如此说放就放,来援助这还当前进着的“罗辑思维”,没理的嘛。

自己及时吗想的确无理的呀!

只是散不花费就是一律脸得意之告知我们,她说其特别自信,以快刀青衣典型的技艺男,讨厌浪费时间的天性,一定忍受不了创业企业开时的琐碎生活,放心,他必然会来我们企业。

新兴,事实证明果然不借,快刀青衣最后决定放弃了和谐之事业,加入了“罗辑思维”,成为今天“罗辑思维”的老三巨头有。

哦,对了,忘记说一样点了,当时排不花得意的讲述快刀青衣第一不善来“罗辑思维”的涉大有意思,这样一个术能力最牛逼的人头,你能设想他错过现在手上华极端充分文化付费平台干啥?

–哈哈,是失去修路由器的。

为此,你可知设想如果创业,你每日还举行会举行些什么啊?你见面无会见后悔自己的支配,所以这坑,我而先报你了。

二:创业的“基线”过低。

咦是创业之“基线”,就是我们经常说的力量,但是能力是词,他并未个量化的专业,到底持有什么力量才称为能力足够,而哪些的力并且叫做能力不够?

噔~噔~噔~噔

即便是基线,大家想象一下,如果将力全写于同摆设A4张上,那么具有什么样的能力就得创业为?或者说创业成功之也许无限特别啊?我会拿出同支铅笔,“呲”的平等名誉,就如此一划。

铅笔线之下的哪怕是休过关,之上代表可以考虑,而这漫长线就是所谓的基线。

假如您的力量没有达到这个基线以上,就不要轻言的去说创业。比如神棍我要好,我关系啥啥异常,总是会闹出各种各样的笑话,一些简练的末节比如统计个数据我还见面渗透的食指,如果给我错过创业。

可是好,但是本人好还非放心的呗。

而说而准备开平家饭馆,你请无至烧饭好吃的法师,不知情开店之一律多重流程比如法律及的流水线,还来内部如何加大你活之营销思路。

只有您发出异常挺的资金,来支持自己犯错的本金,那么最终你的创业的路,很可能是同切开稀碎。创业,确实可以推进学习,但是之前没有足够的基线来支持了前期的开店期,那么你见面一直为各种意想不到之琐事忙的奔溃起来。

创业要求的基线从不是那种别人都非掌握的东西,有时候,一些大家都见面,但是却丢失有人真正的能够做好的东西,可能才是创业之基线。

当,有情侣可以说,这个得请人嘛!嗯,确实好要人帮你解决这些,但是一旦您并这些还解决不好,你的员工以会怎么看您?

退一步说,你说,一个并这些都处不好的人口,是休是可以证明外的大脑是不够清醒的,毕竟这些还容易的,动动脑子,然后擅于总结的丁,这些不还是难以休鸣金收兵客的。

这些都叫来错,我岂能够说明你所谓的换代之想,赚钱的想法,这些纷繁的构思着,你的心血会不出意外给他做到。

君自己力所能及信赖也?

老三:创业无只是从0-1

自身发现一个颇老之误区,很多大学生还是想念当的以为创业就是召开同起别人还不曾想到的事体,不然都未深受创业。

实则创业是什么,首先你得发个协调之原则性。那么一定是呀?我无是什么谈烂的商家一定,产品稳定,只一个

竞争定位

乃得理解好的竞争者到底是啦有人口?

1、  你是行之初创者,你的竞争者是隐形的足发现这个圈子的丁。

2、  你是对方,比如您想挑战饿了呢,美图的外卖霸主地位。

3、 
你是一个略老板,创业之路可能就是是一个电商,也或是某品牌之加盟商。你的竞争者千奇百怪。

自己发现第一种,和亚栽竞争定位的人口,要不就死的生惨痛,要不就混的贼6,但是说实在,只要不是呀最好之身家背景,加上强的原能力,名校支撑。

这种翻新,我们吧便看人物传记就实施,没这个能的口,千万不要所有这种幻想,如果说你有的话,你认为你发出一个特别好之想法,那么先对照前的少数修,你道好够格,我倒是多推荐您去尝试,失败了没啥,但是倘若成功了呢?

使第三种植,才是现行创业的思绪,很多大学生之创业项目都是看起,好像还生把烂大街了,但是怎么它便成功了,而且比别的寒都召开的再好?

不怕是坐,他于具有极其高之创业“基线”情况下,有进行了好几细微的更新。这种翻新或者出在外表,也恐怕是内。

以:一家奶茶店,给好加了个“丧”的主题,产品没有啥,就是突如其来发作起了。但是,如果如本人如此的总人口,突然有矣这般的想法,我能成与否?

自身怀念,还是无克之嘛!“丧”固然是炸的来源,但是背后坚实的“营销思路”那条基线,我莫敷高嘛!

里头怎么宣传,有安渠道,那些方法,有和好之计划吗?能够写有同样学行之有效的企图方案,这些自都不够规范,或者难找到这种专业的总人口。

(能够组建一个靠谱,充满各种能力人的集团,这也是均等栽力量,而想如果创业,如果你产生这种力量,并且上一定的基线也是足以)

从而,现在如给您自己来次左右手之间的“锤子剪刀布”,我思念你应当无会见产生那么纠结了,也足以做出决定了吧。

只要那些满创业想法的大学生宝宝们,是免是异常沮丧,是不是特别绝望,其实毫不这么随便之舍,要明白即便到底自己这么平庸的丁,我之这种想法还直接没熄灭。

今日之自身当同样寒创业企业间工作,平常我会小心的偷师着店的上上下下。合理之我会总结,不成立之我会提出,然后说发生我的看法,接下,我也还见面总结在文章被。我期待由此我自己之总结,我能够尽量的增高我之基线,当然也期待这些能够针对你有点拉扯。

迎关注自我“神棍大大卷”,只要有人愿意看,我会一直总结下的。

留下评论