数组的表示方法：
int[] arr = new int[3];
int[] arr = new int[3]{1,2,3};
int[] arr = {1,2,3};
逻辑运算符（6）4 +2 :
4:& | && ||
2:! ^
位运算符：
位运算是直接对二进制位的运算
3+2+2：
<< >> >>>
& |
~ ^
~取反：就是对二进制数每一位0变1,1变0
对两个整数的值进行互换（可以使用第三方变量）：
class OperatorDemo{
public static void main(String[] args){
int a = 3 , b = 4;
int c;
c = a ;
a = b;
b = c;
}
}
}
对两个整数的值进行互换（不可以使用第三方变量）
class OperatorDemo{
public static void main(String[] args){
int a =3 , b = 4;
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
}
三元运算符：
class Operator {
public void static main(String args[]){
int x = 3,y;
y = (x >1)?100:200;
System.out.println(y);
}
}
获取三个数中较大的数：
class Operator {
public void static main(String args[]){
int x = 1,y = 2, z = 4,temp,max;
temp = (x > y)?x:y;
max = temp > z ? temp : z;
}
}
if条件语句：
class IfDemo{
public void static main(String[] args){
int month = 9;
if(month <1 || month > 12)
System.out.println(month+"月没有对应的季节");
else if (month >= 3 && month <= 5)
System.out.println(month+"月对应春季");
else if (month >=6 && month <= 8)
System.out.println(month+"月对应夏季");
else if (month >= 9 && month <= 11)
System.out.println(month+"月对应秋季");
else
System.out.println(month+"月对应冬季");
}
}
数组:
找寻最值：
class ArrayDemo {
public void static main(String[] args){
int[] arr = {-11,22,44,93,532};
int max = getMax(arr);
System.out.println("数组的最大值是" + max);
}
public int static getMax(int[] arr){
int maxElement = 0;
if(int x = 0 ; x < arr.length ; x ++){
if(arr[x] > maxElement)
maxElement = arr[x];
}
return maxElement;
}
}
或者：
class ArrayDemo {
public void static main(String[] args){
int[] arr = {22,,23,25,56,76,435,345,34,234,15};
int maxIndex = getMaxIndex(arr);
System.out.println("数组的最大值是"+arr[maxIndex]);
}
public int static getMaxIndex(int[] arr){
int maxIndex = 0;
for(int x = 0 ; x < arr.length; x ++){
if(arr[x]> arr[maxIndex]){
maxIndex = x;
}
}
return maxIndex;
}
}
选择排序：
冒泡排序：
每列一直相邻比较，且较大者右移
class ArrayDemo {
public void static main(String[] args){
int[] arr = {22,44,55,66,77,88,99,9999};
System.out.print("排序之前的数组 = ”）；
printArray(arr);
bubbleSort(arr);
System.out.print("排序之后的数组 = ");
}
public void bubbleSort(int[] arr){
for(int x = 0 ; x <= arr.length - 1 ; x ++){
for(int y = 0 ; y <= arr.length - 1 - x ; y ++){
if(arr[y] >arr[y+1]){
int temp = arr[y];
int arr[y] = arr[y +1];
int arr[y+1] = temp;
}
}
}
}
public void printArray(int[] arr){
System.out.print("[");
for(int x ; x <= arr.length ; x ++){
if(x != arr.length - 1 )
System.out.print(","+arr[x]);
else
System.out.println(arr[x] + "]");
}
}
}
二分法（用于有序数列的查找）
class ArrayDemo {
public void static main(String[] args){
int[] arr = {21,90,490,1892,2900};
int index = binarySearch(arr, 490);
System.out.println("index = "+ index);
}
public int static binarySearch(int[] arr, int key){
int min = 0;
int max = arr.length- 1 ;
int mid = (min +max)/2;
while(arr[mid] != key){
if(arr[mid] < key)
min = mid +1;
else if (arr[mid] >key)
max = mid -1;
if(max < min){
return -1;
}
mid = (max +min)/2;
return mid;
}
}
}
或者（位运算符）：
class ArrayDemo{
public void static main(String[] args){
int[] arr = {21,33,33,14,4546,23,56,20,09};
int index = binearySearch(arr,23);
System.out.println("index = " + index);
}
public int static binearySearch(int[] arr,int key ){
int max,min,mid;
max = arr.length - 1;
min = 0;
while(min < max) {
mid = (max +min)>>1;
if(arr[mid]> key )
max = mid - 1;
else if(arr[mid] < key)
min = mid + 1 ;
else
return mid;
}
return -1;
}
}
二分法在jdk中当然api了：
class ArrayDemo{
int[] arr = {32,11,89,33,190}
int index = Array.binarySearch(arr,22);
System.out.println("index = " + index );
}
但返回值是个负值，因为要索引的数字不包含在数组中的话，返回值为：（-（插入点）-1）
获取一个十进制数字的2,8,16进制的表现方式：
二位数组：
求和：
class Array2Demo {
public void static main(String[] args){
int sum;
int[][] arr = {{3,1,8},{8,2,1},{90,222,124,24}};
for(int x = 0 ; x <= arr.length ; x ++ ) {
for (int y = 0 ; y <= arr[x].length ; y ++)｛
sum += arr[x][y];
}
}
System.out.println("sum = " + sum);
}
}
以及所谓的面向对象：（匿名对象的使用）
class Car {
String color = "yellow ";
String price = 1000,000;
public void run(){
System.out.println("wow!!Its so cool to drive such a good car!");
}
}
class CarDemo {
public void static main(String[] args){
//当对对象仅调用一次时，可以用匿名对象
new Car().run();
//匿名对象可以作为实际参数进行传递
show （new Car（））；
}
public void show（Car car）{
ajfjsdjflasj
}
}
封装：
将不需要对外提供的内容都隐藏起来，并提供公共方法对其访问，如getXXX，setXXX
构造函数：
函数名与类名相同
没有返回值
多个构造函数的重载，差别在于参数不同
static关键字的特点：
随着类的加载而加载
优先于对象存在
被所有对象所共享
可以直接被类名所调用
|
|
收藏
淘帖
踩
