JAVA自学（一），JAVA自学(
JAVA自学（一），JAVA自学(
一. java简介1.java和c的关系 1).java起源于C，并且针对C来说使用接口代替了多重继承，并取消了指针，因为指针和继承会使得程序变得复杂。 2).java还通过垃圾自动收集，简化了程序设计人员的资源释放管理工作 3).java通过丰富了类库和API文档及第三方开发包，另外还有大量的java开源项目
2.面向对象 java是一种面向对象的程序设计语言，即语法中不能在类之外定义单独的变量和方法，也就是说，java最外部的数据类型就是对象和类，所有的元素都是通过类和对象访问。
3.分布性 分布性包括操作分布和数据分布。操作分布在多个不同主机上操作，数据分布是通过url对象访问网络对象。
4.可移植性 可移植性包括结构移植和类移植。结构移植因为java程序具有与体系结构无关特性，可以移植到其他主机上，类移植是根据java特性，类库可以移植。
二.jdk
一般来说jdk包含了jre 在macos里是自带jdk1.6的，所以只需要安装eclipse就能运行，而windows下需要安装jdk并且设置环境变量
三.eclipse使用
1. mac下command+alt+/可以自动补全java关键字、也可以用alt+/完整辅助关键字列表，便于调用之前编写过的类和变量
2.在报错红色字体下方使用command+1可以激活修正代码菜单
四.java语言
1. java架构 一个java程序大体分为包、类、main()主方法、标示符、关键字、语句、注释等
2. 标识符 标示符就是一个命名，可以是变量名、类名等等 标示符命名有如下规则 （1）以字母、数字、下划线、$组合而成，但是不能以数字开头，例如7park （2）java中标示符最长可以识别到65535个字符，即2的16次方 （3）不能和关键字、保留字冲突，如this、goto等 （4）java的标示符是区分大小写的，good和Good是不同的标示符
3.java中被赋予一些特定意义的单词叫关键字 例如int、public、for、defalut、if、else等等
4.基本数值类型 （1）分为字符型、数值型、布尔型。其中数值型分为整数型和浮点型。而整数型分为（byte、int、short、long）；浮点型分为（short、double）共8种。
下面针对8种详解
在char字符型中包含一个特殊字符叫转义符\
布尔型的结果只有true、flase
5.变量 变量分为成员变量、局部变量 （1）成员变量是在类体中就定义的变量叫成员变量 而成员变量又分为静态变量和实例变量 例如 public class a1{ int aaa=1; static int bbb=2; } 则aaa是实例变量、bbb是静态变量。静态变量的有效范围可以跨类，甚至到整个应用程序，用法是“类名.静态变量名”
（2）局部变量是在类的方法中声明的变量 局部变量只在当前方法内有效，通俗点说就是在它最近的大括号内有效。
例如
结果就是 23 24
6.运算符 （1）赋值运算符、算术运算符 =、+、-、*、%、 （2）自加、自减运算符 ++a 先将a自加，在参与赋值 a++ 先赋值、再自加 例如a=4 b=++a 则a先自加到5，再将5复制给b，最终 a=b=5 b=a++ 则a先赋值给b，则b=4，a在自加，最终a=5/b=4 （3）比较运算符 >、<、==、>=、<=、！= （4）逻辑运算符 &&、||、！ 与、或、非 （5）位运算符
（6）三元运算符 三元运算符是java中唯一的一个三目运算符，其操作元有3个，第一个条件是表达式、后两个是值，表达式成立取第一个值，不成立取第二个值 例如：int a=10,b=20; int c=a>b?55:66 system.out.println(c) 结果是66 （7）运算符优先级
8类型转换 （1）
例如：
public class classconvert {
public static void main(String[] args) {
byte mybyte=27;
int myint=127;
float myfloat=123.13f;
double mydouble=45.454545;
char mychar=10;
System.out.println(mybyte+myfloat);
System.out.println(mychar+mydouble);
System.out.println(myint+mybyte);
}
}
结果是
（2）强制类型转换 高精度的变量赋值给低精度的变量时必须使用显示型转换运算又称强制类型转换 格式是：（类型名）要转换的值 例如：int a=(int)45.3 则结果是45 long b=(long)56.5F 则结果是56 int c=(int)'d' 则结果是100
9.经典案例 （1）判断一年是否为闰年，下例子中因用到scanner扫描器这个包模块，所以在生面public之前需要import java.until.Scanner 否则在主方法中使用的话会报错，没有调用包的源头
代码如下
import java.util.Scanner;
public class leap_year {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入一个年份：");
int year=scan.nextInt();
if (year%4==0&&year%100!=0||year%400==0){
System.out.println(year+"年是闰年！");
}else{
System.out.println(year+"年不是闰年");
}
}
}
（2）计算一个长方形的面积 代码如下 import java.util.Scanner;
public class aera {
public static void main(String[] args) { Scanner scan= new Scanner(System.in); System.out.println("请输入长方形的长:"); double x= scan.nextDouble(); System.out.println("请输入长方形的宽:"); double y= scan.nextDouble(); double aera=x*y; System.out.println("长方形的面积是"+aera"); }
}
（3）计算球的体积
import java.util.Scanner;
public class Volume {
public static void main(String[] args) {
Scanner scan= new Scanner(System.in);
System.out.println("请输入球体的半径:");
double radius=scan.nextDouble();
final double PI=3.1415926;
double volume=radius*radius*radius*PI*4/3;
System.out.println("球体的体积是"+volume+"！");
}
}
五.流程控制
1.条件语句 （1）最简单的if表达式 if （布尔表达式）{结果} （2）两个情况判断，但是出一个结果 例如int x,y 分别输入x和y的值，然后判断若x<y则输出x<y,若x>y则输出x>y （3）if ...else if (表达式）{结果1} else {结果2} （4）if....else if多分枝判断 if (表达式）{结果1} else if （表达式2）{结果2} .... else (表达式n）{结果n}
2.switch 多分支语句 比如一个人成绩是x，x>90则是好学生 70<x<90 是中等生 x<60是差生，当然可以用if表达，但是显得太笨重，此时用switch完成更简单 switch(表达式） { case 常量值1； 结果1 [break;] case 常量值2; 结果2 [break;] ..... case 常量值n; 结果n [break;] default; 结果n+1 [break;]
//////课间小常识///// hash 属于较散列，又常口译成哈希，就是将任意长度的输入通过散列（哈希）算法变成固定长度的输出，当然输出的长度远远小于输入。 一般哈希算法都是将任意长度的二进制值映射为较短的二进制值，一般用于快速查找和加密算法。 简单解释：哈希(Hash)算法,即散列函数。它是一种单向密码体制,即它是一个从明文到密文的不可逆的映射,只有加密过程,没有解密过程。
///////////////////////
3.循环语句 （1）while循环语句 while（条件表达式） {执行语句} 当条件表达式为true时执行语句，循环回去直至表达式为flase时退出循环。 例如
public class sum {
public static void main(String[] args) {
int x=1;
int sum=0;
while(x<=10){
sum=sum+x;
x++;
}
System.out.println("1到10之和是"+sum);
}
}
切记while(表达式)后面不要加分好，此时java不会报错，而是进入死循环。。（2）do ...while循环语句 do while与while类似，却别是while是先判断在循环，而do while是先执行一次循环在开始判断
do { 执行语句} while(表达式）； 注意此处的while一定要加分号。 （3）for 循环语句 for （表达式1；表达式2；表达式3） {执行语句} 其中 表达式1是初始化表达式，负责完成变量的初始化 表达式2是循环条件表达式，值为boolean型表达式，指定循环条件 表达式3是循环后操作表达式，负责修正变量，改变循环条件
例如：
public class sum2 {
public static void main(String[] args) {
int sum=0;
int i;
for (i=2;i<=100;i+=2)
{sum=sum+i;
}
System.out.println("2到100之间所有偶数的和是"+sum);
}
}
/////////// 其中i+=2就相当于i=i+2（4）foreach语句 for(元素变量x:遍历对象obj） {引用了x的java语句；} foreach语句中的元素变量x不用对其初始化。 例：
public class array {
public static void main(String[] args) {
int arr[]={5,15,25};
System.out.println("一堆数组中的数字分别是");
for (int x:arr)
{
System.out.println(x+"\t");
}
}
}
由此可见，用foreach语句非常便于我们遍历数组。
例子2，遍历汉字数组
public class array {
public static void main(String[] args) {
String aves[]={"白鹭","丹顶鹤","百灵鸟","喜鹊","乌鸦"};
System.out.println("公园里有好多鸟");
for (int i=0;i<aves.length;i++)
{
System.out.println(aves[i]+"\t");
}
}
}
例子3 双循环 99乘法表
public class multiplicationtabe {
public static void main(String[] args) {
for (int i=1;i<=9;i++){
for (int j=1;j<=i;j++){
System.out.print(j+"*"+i+"="+i*j+"\t");
}
System.out.println();
}
}
}
4.跳转语句 java中一共提供了3中跳转语句，分别是break、continue、return （1）break break在前面的switch语句中见到过，当然在其他循环语句中也可以用break，其主要目的就是强制跳出循环。 （2）continue continue只能在for 、while和do..... while语句中使用，用于让程序跳过其后面的语句，进行下一次循环。
当continue终止本次循环后，当循环结果为false，则退出循环，否则返回下一次循环。 （3）return return可以从一个方法返回，并把控制权交给调用它的语句 return [表达式] 例子：遍历一个数组，在其中某个元素的时候break，并打印在这个元素之前的信息
public class breakcyc {
public static void main(String[] args) {
String aves[]=new String[]{"白鹭","丹顶鹤","百灵鸟","喜鹊","乌鸦"};
System.out.println("告诉我当你发现喜鹊之前都有什么鸟");
for (String string:aves){
if (string.equals("喜鹊"))
break;
System.out.println("有"+ string+" " );
}
}
}
例子：循环体的过滤器，一方面用break中断某种情况，但又不退出循环，这又需要continue配合public class Cycfliter {
public static void main(String[] args) {
String array[] =new String[]{"白鹭","喜鹊","乌鸦","老鼠","仙鹤","黄鹂"};
System.out.println("最近花园中出现了老鼠，请抓走") ;
int mousecount=0;
for (String x:array){
if (x.equals("老鼠")){
System.out.println("发现一只老鼠，抓到笼子里");
mousecount++;
continue;
}
System.out.println("抓住一只鸟，发现了:"+x);
}
System.out.println("一共抓住了"+mousecount+"只老鼠");
}
}
结果是例子：输出一个空心菱形
public class HollowRhombus {
public static void main(String[] args) {
graph(8);
}
public static void graph(int size) {
if (size%2==0){
size++;
}
for (int i=0;i<size/2+1;i++){
for (int j=size/2+1;j>i+1;j--){
System.out.print(" ");
}
for (int j=0;j<2*i+1;j++){
if (j==0||j==2*i){
System.out.print("*");
}else{
System.out.print(" ");
}
}
System.out.println("");
}
for (int i=size/2+1;i<size;i++){
for (int j=0;j<i-size/2;j++){
System.out.print(" ");
}
for (int j=0;j<2*size-1-2*i;j++){
if (j==0||j==2*(size-i-1)){
System.out.print("*");
}else{
System.out.print(" ");
}
}
System.out.println("");
}
}
}
六.数组
数组是具有相同数据类型的一组数据组合，根据维度可以分为一维数组、二维数组、n维数组。 1.一维数组 数组作为对象允许是用new关键字进行内存分配，声明一维数组有两种形式，分别是 int arr[] String str[] 分别代表整型数组和字符串数组 数组名称 = new 数组元素类型[数组元素个数]
值得注意的是声明数组 和分配内存可以一起进行，不必分开执行 例如 int month[]=new month[12]
初始化数组 String month[]=new month[]{"mondy","tuesday"....."sunday"} 或者String month[]={"mondy","tuesday"....."sunday"}
2.二维数组
二维数组初始化与一维类似 int arry[][]=new[][]{(1,9),(2,8)};
对于整型二维数组，创建后系统会自动初始化每个元素的值为0
3.三维数组
4.填充替换数组元素
（1）数组初始化定义好后，可以通过Arrays类的静态替换fill（）来替换数组中的元素。 格式是 fill（int[] a,int value) 注意需要调用java.util.Arrays这个包
例子，将数组arr[]中的元素都用值8替换
import java.util.Arrays;
public class fillarray {
public static void main(String[] args) {
int arr[]=new int[]{1,2,3,4,5,6};
Arrays.fill(arr, 8);
for (int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
（2）具体细化到某个元素的替换，需要用到fill（)方法的fromindex toindex 格式是fill (int arr[],int fromindex,int toindex,int vaule)其中fromindex是包括的，toindex是不包括的
import java.util.Arrays;
public class fillarray {
public static void main(String[] args) {
int arr[]=new int[]{1,2,3,4,5,6};
Arrays.fill(arr, 3, 5, 8);
for (int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
}
结果是
（3）对数组进行排序 排序依然用到java.util.Arrays包，调用的是sort()方法 格式Arrays.sort(object)
import java.util.Arrays;
public class fillarray {
public static void main(String[] args) {
int arr[]=new int[]{1,9,3,7,5,6};
Arrays.sort(arr);
for (int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
}
}
结果是1，3，5，6，7，9 默认排序sort结果是升序。 另java语言中string的排序算法是根据字典编排的，所以数字在字母前面，大写在小写前面。
（4）复制数组 用到copyOf（）方法 格式 Arrays.copyOf(arr,int newlength);
代码
import java.util.Arrays;
public class fillarray {
public static void main(String[] args) {
int arr[]=new int[]{1,9,3,7,5,6};
for (int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.print("\n");
int newarr[]=Arrays.copyOf(arr, 8);
for (int i=0;i<newarr.length;i++){
System.out.print(newarr[i]+" ");
}
}
}
结果
方法2，用copyOfRange()方法 格式 Arrays.copyOfRange(arr,int fromindex,int toindex) 例子
import java.util.Arrays;
public class copyarray {
public static void main(String[] args) {
int arr[]=new int[]{1,9,3,7,5,6};
for (int i=0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
System.out.print("\n");
int newarr[]=Arrays.copyOfRange(arr, 1, 4);
for (int i=0;i<newarr.length;i++){
System.out.print(newarr[i]+" ");
}
}
}
结果（5）例子5，对比一维数组和二维数组占用内存
public class comparememery {
public static void main(String[] args) {
int num1=1024*1024*2;
int arr1[]=new int[num1];
for (int i=0;i<arr1.length;i++){
arr1[i]=i;
}
long memery1=Runtime.getRuntime().totalMemory()/1024/1024;
System.out.println("一维数组占用的内存是"+memery1);
int num2=1024*1024;
int arr2[][]=new int[num2][2];
for (int i=0;i<arr2.length;i++){
arr2[i][0]=i;
arr2[i][1]=i;
}
long memery2=Runtime.getRuntime().totalMemory()/1024/1024;
System.out.println("二维数组占用的内存是"+memery2);
}
}
结果都是123，奇怪，理论上二维数组占用的内存应该更大，此问题待排查。
经典案例，冒泡排序。 比较相邻两个数，按大小顺序替换。
public class BubbleSort {
public static void main(String[] args) {
int arr[]=new int[]{45,1,36,29,78,94,57};
for (int i=1;i<arr.length;i++){
for (int j=0;j<arr.length-i;j++){
if (arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
System.out.print(arr[j]+" ");
}
for (int j=arr.length-i;j<arr.length;j++){
System.out.print(arr[j]+" ");
}
System.out.println();
}
}
}
六 字符串
1.声明格式 String a =new String ();
2.获取字符串长度 a.length
3.获取指定字符的索引位置 str.indexOf(key) str.lastIndexOf(key)
例如 Stings str=new String(student)
获取指定索引位置的字符 str.charAt(int index) 例子 string s="hellow world" char a=s.charAt(6); 输出a 结果是w
4.去除字符串中的空格。
（1）使用StringTokenizer（）方法 格式： StringTokenizer(String str,String delim)
例子
import java.util.StringTokenizer;
public class Stringto {
public static void main(String[] args) {
String text=" We are studets ";
StringTokenizer s=new StringTokenizer(text, " ");
StringBuffer sb=new StringBuffer();
int i=1;
while(s.hasMoreTokens()){
i++;
sb.append(s.nextToken());
}
System.out.print(sb.toString());
}
}
（2）用replaceAll()方法
格式：str.replaceAll(String regex,String replacement)
例子
public class Stringto {
public static void main(String[] args) {
String text=" We are students ";
String s=text.replaceAll("students", "teacher");
System.out.print(s);
}
}
5.判断字符串
判断eq两个字符串是否相等
（1）equals（）方法
str.equals(String otherstr)
（2）equalsIgnoreCase()方法
此方法是忽略大小写的方法
str.equalsIgnoreCase(String otherstr)
注意比较运算符“==”是用来比较内存位置，不能用来比较字符串！
判断字符串首字符或者尾字符
str.startWith(String prefix)
6.字母大小写转换
toLowerCase()方法和toUpperCase()方法
7字符串分割
（1）split方法
str.split(Stings sign)
8.格式化字符串
例子
Strings str1=String.format("%d",10*20); 200以十进制格式显示
Strings str2=String.format("%b",10<20); 10<20的结果以布尔型格式显示
Strings str3=String.format("%x",200); 200以十六进制格式显示
9.正则表达式
验证一个ip地址是否合法。
import java.util.Scanner;
public class CheckIPaddress {
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println("请输入一个IP地址：");
String ip=scan.next();
System.out.println("您输入的IP地址是"+ip);
if (ip!=null&&!ip.isEmpty()){
String regex="^(1\\d{2}|2[0-4]\\d|25[0-5][1-9]\\d|[1-9])\\."
+"(1\\d{2}|2[0-4]\\d|25[0-5][1-9]\\d|\\d)\\."
+"(1\\d{2}|2[0-4]\\d|25[0-5][1-9]\\d|\\d)\\."
+"(1\\d{2}|2[0-4]\\d|25[0-5][1-9]\\d|\\d)$";
if (ip.matches(regex)){
System.out.println(ip+"是合法IP地址");
}else{
System.out.println(ip+"不是合法IP地址");
}
}
}
10.字符串生成器 StringBuilder类 新建的StringBuilder对象初始容量是16个字符，可以自行指定初始长度，也可以动态添加、删减长度。 例子对比String和StringBuilder在对字符串做更新操作时所用的时间差。 public class StringBuilder {
public static void main(String[] args) { String str =" "; long startTime=System.currentTimeMillis(); for(long i=0;i<1000;i++){ str=str+i; } long endTime=System.currentTimeMillis(); long time=endTime-startTime; System.out.println("String所消耗的时间是："+time); StringBuilder sb=new StringBuilder(); startTime=System.currentTimeMillis(); for (long j=0;j<1000;j++){ sb.append(j); } endTime=System.currentTimeMillis(); time=endTime-startTime; System.out.print("StringBuiler所消耗的时间是"+time); }
}
例子：将汉字和字母转换成Unicode码 Unicode码是国际通用的一种计算机码，
代码
import java.util.Scanner; public class Unicode { public static void main(String[] args) { Scanner scan=new Scanner(System.in); System.out.println("请输入被转换内容"); String text=scan.next(); char[] charArray=text.toCharArray(); StringBuilder sb=new StringBuilder(); for (char c:charArray){ sb.append((int)c+""); } System.out.println(text+"的Unicode码是"+sb.toString()); }
}
相关文章
- 暂无相关文章
用户点评