JAVA中数组总结（课堂总结）
数组的特点：
Arrays(数组）
一种简单的数据结构
元素具有相同的数据类型
一旦创建之后，尺寸保持不变
元素在内存中连续分布
例子一：按引用与按值传递的示例
源代码：
// PassArray.java
// Passing arrays and individual array elements to methods public class PassArray { public static void main(String[] args) {
int a[] = { 1, 2, 3, 4, 5 };
String output = "The values of the original array are:\n"; for (int i = 0; i < a.length; i++)
output += " " + a[i]; output += "\n\nEffects of passing array " + "element call-by-value:\n"
+ "a[3] before modifyElement: " + a[3]; modifyElement(a[3]); output += "\na[3] after modifyElement: " + a[3]; output += "\n Effects of passing entire array by reference"; modifyArray(a); // array a passed call-by-reference output += "\n\nThe values of the modified array are:\n"; for (int i = 0; i < a.length; i++)
output += " " + a[i]; System.out.println(output);
} public static void modifyArray(int b[]) {
for (int j = 0; j < b.length; j++)
b[j] *= 2;
} public static void modifyElement(int e) {
e *= 2;
} }
输出结果截图：
aaarticlea/png;base64,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" alt="" />
分析：
按引用传递与按值传送数组类型方法参数的最大关键在于：
使用前者时，如果方法中有代码更改了数组元素的值，实际上是直接修改了原始的数组元素。
使用后者则没有这个问题，方法体中修改的仅是原始数组元素的一个拷贝。
例子二：数组之间的赋值：
源代码：
public class ArrayInRam {
public static void main(String[] args) {
// 定义并初始化数组，使用静态初始化
int[] a = { 5, 7, 20 };
System.out.println("a数组中的元素：");
// 循环输出a数组的元素
for (int i = 0; i < a.length; i++) {
System.out.print(a[i] + ",");
}
// 定义并初始化数组b，使用动态初始化
int[] b = new int[4];
// 输出b数组的长度
System.out.println("\nb数组的初始长度为：" + b.length);
// 因为a是int[]类型，b也是int[]类型，所以可以将a的值赋给b。
// 也就是让b引用指向a引用指向的数组
b = a;
System.out.println("b=a,赋值之后，b数组的元素为：");
// 循环输出b数组的元素
for (int i = 0; i < b.length; i++) {
System.out.print(b[i] + ",");
}
// 再次输出b数组的长度
System.out.println("\n赋值之后，b数组的长度为：" + b.length);
}
}
实验结果截图：
分析：
代码中b=a;表示将数组a赋值给b，则之后输出的b的长度就等于a的长度。
例子三：利用二维数组和循环语句绘制五子棋盘
源代码：
import java.io.*; public class QiPan
{
//定义一个二维数组来充当棋盘
private String[][] board;
//定义棋盘的大小
private static int BOARD_SIZE = 15;
public void initBoard()
{
//初始化棋盘数组
board = new String[BOARD_SIZE][BOARD_SIZE];
//把每个元素赋为"╋"，用于在控制台画出棋盘
for (int i = 0 ; i < BOARD_SIZE ; i++)
{
for ( int j = 0 ; j < BOARD_SIZE ; j++)
{
board[i][j] = "╋";
}
}
}
//在控制台输出棋盘的方法
public void printBoard()
{
//打印每个数组元素
for (int i = 0 ; i < BOARD_SIZE ; i++)
{
for ( int j = 0 ; j < BOARD_SIZE ; j++)
{
//打印数组元素后不换行
System.out.print(board[i][j]);
}
//每打印完一行数组元素后输出一个换行符
System.out.print("\n");
}
}
public static void main(String[] args)throws Exception
{
QiPan gb = new QiPan();
gb.initBoard();
gb.printBoard();
//这是用于获取键盘输入的方法
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String inputStr = null;
System.out.println("请输入您下棋的座标，应以x,y的格式：");
//br.readLine()：每当在键盘上输入一行内容按回车，刚输入的内容将被br读取到。
while ((inputStr = br.readLine()) != null)
{
//将用户输入的字符串以逗号（,）作为分隔符，分隔成2个字符串
String[] posStrArr = inputStr.split(",");
//将2个字符串转换成用户下棋的座标
int xPos = Integer.parseInt(posStrArr[0]);
int yPos = Integer.parseInt(posStrArr[1]);
//把对应的数组元素赋为"●"。
gb.board[xPos - 1][yPos - 1] = "●";
/*
电脑随机生成2个整数，作为电脑下棋的座标，赋给board数组。
还涉及
1.座标的有效性，只能是数字，不能超出棋盘范围
2.如果下的棋的点，不能重复下棋。
3.每次下棋后，需要扫描谁赢了
*/
gb.printBoard();
System.out.println("请输入您下棋的座标，应以x,y的格式：");
}
}
}
实验结果截图：
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAWQAAAE2CAIAAADZP3+LAAAJMUlEQVR4nO3b25HbSBZFUdgFD9qRtCetSWfSGMwHARAgi9JVqKQ53bHWx8SoLouPamIzicey3Yy2tLF96dtGy7L8tcf6T4wgwnL/p1gEjiCCWOSPIIJY5I8gwrJtW1s++eef7xtt27ZtYzxjsW3b9oce698/Eg7i/B9WFka/OIIIYpE/gghikT+CCGKRP4IIy89vAiAWQJFYACViAZSIBVAiFkCJQ6f5I4ggFvkjiCAW+SOIIBb5I4jw9y5RN/qVkXAQx8oifwQRxCJ/BBHEIn8EEcQifwQRnMEJlIgFUCIWQIlYACViAZSIBVDi0Gn+CCKIRf4IIohF/ggiiEX+CCK4RD1zJBzEsbLIH0EEscgfQQSxyB9BBLHIH0EEZ3ACJWIBlIgFUCIWQIlYACViAZQ4dJo/gghikT+CCGKRP4IIYpE/ggguUc8cCQdxrCzyRxBBLPJHEEEs8kcQQSzyRxDBGZxAiVgAJWIBlIgFUCIWQIlYACUOneaPIIJY5I8ggljkjyCCWOSPIIJL1DNHwkEcK4v8EUQQi/wRRBCL/BFEEIv8EURwBidQIhZAiVgAJWIBlIgFUCIWQIlDp/kjiCAW+SOIIBb5I4ggFvkjiOAS9cyRcBDHyiJ/BBHEIn8EEcQifwQRxCJ/BBGcwQmUiAVQIhZAiVgAJWIBlIgFUOLQaf4IIohF/ggiiEX+CCKIRf4IIrhEPXMkHMSxssgfQQSxyB9BBLHIH0EEscgfQQRncAIlYgGUiAVQIhZAiVgAJWIBlDh0mj+CCGKRP4IIYpE/gghikT+CCC5RzxwJB3GsLPJHEEEs8kcQQSzyRxBBLPJHEMEZnECJWAAlYgGUiAVQIhZAiVgAJQ6d5o8ggljkjyCCWOSPIIJY5I8ggkvUM0fCQRwri/wRRBCL/BFEEIv8EUQQi/wRRHAGJ1AiFkCJWAAlYgGUiAVQIhZAiUOn+SOIIBb5I4ggFvkjiCAW+SOI4BL1zJFwEMfKIn8EEcQifwQRxCJ/BBHEIn8EEZzBCZSIBVAiFkCJWAAlYgGUiAVQ4tBp/ggiiEX+CCKIRf4IIohF/ggiuEQ9cyQcxLGyyB9BBLHIH0EEscgfQQSxyB9BBGdwAiViAZSIBVAiFkCJWAAlYgGUOHSaP4IIYpE/gghikT+CCGKRP4IILlHPHAkHcaws8kcQQSzyRxBBLPJHEEEs8kcQwRmcQIlYACViAZSIBVAiFkCJWAAlDp3mjyCCWOSPIIJY5I8ggljkjyCCS9QzR8JBHCuL/BFEEIv8EUQQi/wRRBCL/BFEcAYnUCIWQIlYACViAZSIBVAiFkCJQ6f5I4ggFvkjiCAW+SOIIBb5I4jgEvXMkXAQx8oifwQRxCJ/BBHEIn8EEcQifwQRnMEJlIgFUCIWQIlYACViAZSIBVDi0Gn+CCKIRf4IIohF/ggiiEX+CCK4RD1zJBzEsbLIH0EEscgfQQSxyB9BBLHIH0EEZ3ACJWIBlIgFUCIWQIlYACViAZSIBVCyx2K050H+/f/POV9noy1rn/c7GO3DhQyjrX2WTh+YfT3vdvQ+t22bvY+Xp7XNvu7/etz1p4e8Pvdt9na76adf/fkze30SX979b/n8Ao+HeXn09992tgZ/zrGymGPM2ddlWZZlXddlWdY25jb7uqy9t2VpY/Y+vn673rbp/f566/OxzY92vTjqeJCL64Yxeh+zn5e2reu+tZ6/1sZLULbrA+w3W9djGz6r8ysXaJ23Xvu8PvB5f2dEzufw+J1LVd+zev5l1svs/NePXuA2ex9jjDlab+3Ty9h/64v/GPAdjliM8bqy2H8yxhitjdnXtfe2rH2+bQmzt7Xf3qCzt7X10Vvvvc/9Xfzq7cf7NrqufZzdOm4yx5iP3xm99/t0tDa2PWV9PDeXZ5eum09hYxq9jzkvf5XnAuJZqPG29DkWWV8twF5e53re3XpU6OML3P8srbW1z9Fba7fUvF+vevlvCd9n2Y63XDveoW08PiXbGM9347q21tr6+IDrtzTM3l6DMOfjB6O1PufofZwbxdPx+X3ZsGZf19Zan8eCoL/FYm29j8uH/H6r60qmP9M1+9pa771dN6bnl5QPRu/zkYHH/16+bLy89pfg7X+un9XorMXla84PX2BbWtsTfi/1eL6w1u9PDb7ZubLoj7VwH48N5LoV7Nv9HpLex+1d+WH1u99ujvaeidsvXlfbY/RjBf66srh/1rbLAmIbvffeH5tZ74+XsG+Mo7c+5pxn0Eqfuo9nduRuXJdd59ea9fx7Xcy+ruun1/tyu5cdOj94gWP0fcX06NDjps9kHH/Il2B/0Wf4DZdYHMvfx8ridVdB64/P+5dYXBpx3ys355y9j2Mfx+tmtX31NeTxlWVcvtQ/v9Kfq/T5+vuzt7X33o4vSP3cBM/netv6zy8vn74s7M91f8jbV7Rt9raux9phtNb67WN+7XO775TYXnZnXP5Y/bo38uMLfPwVe+9r62P0dt0j8/KHfN01Dd9pj8X+Bv/5yqLPeV8e37+QrGdknt8ltm3f87G8rT3e39THBrIubVw3ux/E4v1z//jX/lyPn+73vTfg83GR++pj3w9y/OyZkHZ8zJ97Fq6Je9mJ+UUt7j/7wQt8y9f1RvcdM5eFkJUF3+x+nsXl2MF1x13v8/Ep3S67Nz8cpXu8oR8fbuNyVOP9+/RXexpnb/tu1NuDn9vEc1VwPTzx3LPy3DvRjl2TfTyisRYPhdzu8LzP5xLieFG/sCF+dXj5dWHz8QUez+ny0OdvfrE6+tGBGPgdTsr6s173L+w+np0CscTib3ssD3z4868jFkCJWAAlYgGUiAVQIhZAiVgAJWIBlIgFUCIWQIlYACViAZSIBVAiFkCJWAAlYgGUiAVQIhZAiVgAJWIBlIgFUCIWQIlYACViAZSIBVAiFkCJWAAlYgGUiAVQIhZAiVgAJWIBlIgFUCIWQIlYACViAZSIBVAiFkCJWAAlYgGUiAVQIhZAiVgAJWIBlIgFUCIWQIlYACViAZSIBVAiFkCJWAAlYgGUiAVQIhZAiVgAJWIBlIgFUCIWQIlYACViAZSIBVAiFkCJWAAlYgGUiAVQIhZAiVgAJWIBlIgFUCIWQIlYACViAZSIBVAiFkCJWAAl/wOPtCIC4/e/TQAAAABJRU5ErkJggg==" alt="" />
aaarticlea/png;base64,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" alt="" />
aaarticlea/png;base64,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" alt="" />
例子四：将整数转换为汉字读法字符串（比如“1123”转换为“一千一百二十三”）
源代码：
package hanzidufa; public class Num2Rmb
{
private String[] hanArr = {"零" , "一" , "二" , "三" , "四" ,
"五" , "六" , "七" , "八" , "九"};
private String[] unitArr = {"十" , "百" , "千","万","十万","百万"}; /**
* 把一个四位的数字字符串变成汉字字符串
* @param numStr 需要被转换的四位的数字字符串
* @return 四位的数字字符串被转换成的汉字字符串。
*/
private String toHanStr(String numStr)
{
String result = "";
int numLen = numStr.length();
//依次遍历数字字符串的每一位数字
for (int i = 0 ; i < numLen ; i++ )
{
//把char型数字转换成的int型数字，因为它们的ASCII码值恰好相差48
//因此把char型数字减去48得到int型数字，例如'4'被转换成4。
int num = numStr.charAt(i) - 48;
//如果不是最后一位数字，而且数字不是零，则需要添加单位（千、百、十）
if ( i != numLen - 1 && num != 0)
{
result += hanArr[num] + unitArr[numLen - 2 - i];
}
//否则不要添加单位
else
{ //上一个数是否为“零”，不为“零”时就添加
if(result.length()>0 && hanArr[num].equals("零") && result.charAt(result.length()-1)=='零')
continue;
result += hanArr[num];
}
}
//只有个位数，直接返回
if(result.length()==1)
return result; int index=result.length()-1;
while(result.charAt(index)=='零'){
index--;
}
if(index!=result.length()-1)
return result.substring(0,index+1);
else {
return result;
}
} public static void main(String[] args)
{
Num2Rmb nr = new Num2Rmb();
System.out.println("只支持整数（0~百万）");
//测试把一个四位的数字字符串变成汉字字符串
System.out.println(nr.toHanStr("0"));
System.out.println(nr.toHanStr("1"));
System.out.println(nr.toHanStr("10"));
System.out.println(nr.toHanStr("15"));
System.out.println(nr.toHanStr("110"));
System.out.println(nr.toHanStr("123"));
System.out.println(nr.toHanStr("105"));
System.out.println(nr.toHanStr("1000"));
System.out.println(nr.toHanStr("1100"));
System.out.println(nr.toHanStr("1110"));
System.out.println(nr.toHanStr("1005"));
System.out.println(nr.toHanStr("1105"));
System.out.println(nr.toHanStr("1111"));
System.out.println(nr.toHanStr("10000"));
System.out.println(nr.toHanStr("10001"));
System.out.println(nr.toHanStr("10011"));
System.out.println(nr.toHanStr("10111"));
System.out.println(nr.toHanStr("11111"));
System.out.println(nr.toHanStr("11000"));
System.out.println(nr.toHanStr("11100"));
System.out.println(nr.toHanStr("11110"));
System.out.println(nr.toHanStr("101110"));
System.out.println(nr.toHanStr("1001110")); }
}
实验结果截图：
aaarticlea/png;base64,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" alt="" />
例子五：将数字表示金额“汉字表达法”
源代码：
package hanzidufa; public class Num2Rmb
{
private String[] hanArr = {"零" , "壹" , "贰" , "叁" , "肆" ,
"伍" , "陆" , "柒" , "捌" , "玖"};
private String[] unitArr = {"分","角","元","十","百","千","万","十万","百万"}; /**
* 把一个四位的数字字符串变成汉字字符串
* @param numStr 需要被转换的四位的数字字符串
* @return 四位的数字字符串被转换成的汉字字符串。
*/
String toHanStr(String numStr)
{
String result = "";
int numLen = numStr.length();
int flag;
flag=numStr.indexOf('.');
String numStr1,numStr2;
numStr1=numStr.substring(0,flag);
numStr2=numStr.substring(flag+1,numLen);
int numLen1=numLen-flag;
int numLen2=2;
//依次遍历数字字符串的每一位数字
for (int i = 0 ; i < numLen1 ; i++ )
{
//把char型数字转换成的int型数字，因为它们的ASCII码值恰好相差48
//因此把char型数字减去48得到int型数字，例如'4'被转换成4。
int num = numStr1.charAt(i) - 48;
//如果不是最后一位数字，而且数字不是零，则需要添加单位（千、百、十） result += hanArr[num] + unitArr[numLen - 2 - i];
}
//只有个位数，直接返回
for(int j=0;j<2;j++)
{
int num1=numStr2.charAt(j)-48;
result += hanArr[num1] + unitArr[1 - j];
}
return result;
} public static void main(String[] args)
{
Num2Rmb nr = new Num2Rmb();
System.out.println("只支持整数（0~百万）");
//测试把一个四位的数字字符串变成汉字字符串
System.out.println(nr.toHanStr("123.11")); }
}
实验结果截图：
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAVEAAACHCAIAAAAgBP2TAAADOUlEQVR4nO3Y0W7jNhRAQf//T6cPBYJuLFOXdJIWPTNPiUxTlMAjbfbxAZQ8/u0FAL9K89Cyav7xuPn01v3pXwx7Pjic7XbMseHkB2s4mPlHr5T/tz+20TsZn+3Cv781Kfx2/mESw0s7uxvHYyb3eXiBsHb+np+PPNjll78uznKZ1nDxQ7cTHq9hMuwXLpCIvZfb9RRvbL7b1+DH4P22u+D52o4fUq+WejDzwfyw8INV3I78eL1xP4/v7vXH3QPiJ3xey1bGu/PPj8PCW3/PL/bccDuud/NlS8fn3brAN+/G+qOtmRdXdPspPNt7Ky628mLkYlu/mmG4lQ/KvFze2QKOm5/P/Lh66n25LtmzZeN/lS++/JPv+d2tvNXVcPDu3ZiP35r5cp1S58x/7u/5L18fVnE5z3rlw5Fzizm/5RSa51v80nt+0eR65knMn4+P2wfKcG3//Ojsbkwufz7z7rJhYfp6/K7mX/1wO/5y5nUkrwZsNT8/vsh48uTaPa55zvz2e/57m18ve7Kwj6eHyO20B8+Ry/Fv3mfNc+Y+jHXYB3v3+dPLI4tTjK9udV2XB88GPB+/bf545tvjsPb138m3/vjyznt+WMWXEz2f4nLmyYLXq30+7/xuTGaeL/h25i8TwhZbB1o0Dy2ahxbNQ4vmoUXz0KJ5aNE8tGgeWjQPLZqHFs1Di+ahRfPQonlo0Ty0aB5aNA8tmocWzUOL5qFF89CieWjRPLRoHlo0Dy2ahxbNQ4vmoUXz0KJ5aNE8tGgeWjQPLZqHFs1Di+ahRfPQonlo0Ty0aB5aNA8tmocWzUOL5qFF89CieWjRPLRoHlo0Dy2ahxbNQ4vmoUXz0KJ5aNE8tGgeWjQPLZqHFs1Di+ahRfPQonlo0Ty0aB5aNA8tmocWzUOL5qFF89CieWjRPLRoHlo0Dy2ahxbNQ4vmoUXz0KJ5aNE8tGgeWjQPLZqHFs1Di+ahRfPQonlo0Ty0aB5aNA8tmocWzUOL5qFF89CieWjRPLRoHlo0Dy2ahxbNQ4vmoUXz0KJ5aNE8tGgeWjQPLZqHFs1Di+ahRfPQonlo0Ty0aB5aNA8tmocWzUOL5qFF89DyF/xAmxyReevkAAAAAElFTkSuQmCC" alt="" />
例子六：利用数组储存大数字，并实现阶乘运算
源代码：
import java.util.Scanner;
public class BignumberJiecheng {
private static int[] resultArray = new int[10000000];
static int resultJinwei = 0;
static long index = 0;
public static void main(String[] args) {
System.out.println("请输入要求阶乘的N的值：");
Scanner sin = new Scanner(System.in);
int number = sin.nextInt();
long maxIndex = method(number);
System.out.println("阶乘为:");
for (long i = maxIndex-1; i >= 0; i--) {
System.out.print(resultArray[(int) i]);
if(i % 100 == 0) { //此处对输出格式做处理时因为eclipse编译器的控制台每行输出的长度有限定，所以处理成每行输出100个数
System.out.println();
}
}
}
public static long method(long number) {
long maxIndex = 1;
int temp = 0;
//int tempMaxIndex = 0;
resultArray[0] = 1;
for (long i = 1; i <= number; i++) {
for (long j = 0; j < maxIndex; j++) {
resultArray[(int) j] *= i;
resultArray[(int) j] += resultJinwei;
temp = resultArray[(int) j];
if (temp >= 10) {
resultArray[(int) index] = temp % 10;
resultJinwei = temp / 10;
index++;
if(maxIndex<index+1)
maxIndex = index+1;
} else {
index++;
resultJinwei = 0;
}
}
index = 0;
}
return maxIndex;
}
}
实验截图：
aaarticlea/png;base64,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" alt="" />
例子七：随机生成10个数（1~10），输出数组内容，并输出数组的和。
源代码：
package sjs;
public class sjsj {
public static void main(String[] args) {
// TODO Auto-generated method stub
int a[]=new int [10];
int sum=0;
for(int i=0;i<10;i++)
{
a[i]=1+(int)(Math.random()*10);
sum+=a[i];
}
for(int j=0;j<10;j++)
{
System.out.println(a[j]);
}
System.out.print("数组之和为："+sum);
}
}
实验结果截图：
aaarticlea/png;base64,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" alt="" />
JAVA中数组总结（课堂总结）的更多相关文章
- java中数组的相关知识
1. 2.数组的命名方法 1)int[]ages=new int[5]; 2) int[]ages; ages=new int[5]; 3)int[]ags={1,2,3,4,5}; 4)int[ ...
- Java中数组的特性
转载:http://blog.csdn.net/zhangjg_blog/article/details/16116613 数组是基本上所有语言都会有的一种数据类型,它表示一组相同类型的数据的集合,具 ...
- 在java 中,数组与 List<T> 类型的相互转换
在java中,数组与List<T> 之前进行互相转换,转换方法可总结为以下几种: 一. 将 数组转换成List<T> 1. 使用 Collections 的addAll 方法 ...
- Java中数组的初始化方式
Java中数组的初始化方式 初始化方式有两种: 1.静态初始化:初始化时由程序猿显式指定每一个数组元素的初始值,由系统指定数组长度 2.动态初始化:初始化时由程序猿仅仅指定数组长度,由系统为数组 ...
- java中数组复制的两种方式
在java中数组复制有两种方式: 一:System.arraycopy(原数组,开始copy的下标,存放copy内容的数组,开始存放的下标,需要copy的长度); 这个方法需要先创建一个空的存放cop ...
- Java中数组的插入，删除，扩张
Java中数组是不可变的,但是可以通过本地的arraycop来进行数组的插入,删除,扩张.实际上数组是没变的,只是把原来的数组拷贝到了另一个数组,看起来像是改变了. 语法: System.arrayc ...
- java中数组、集合、字符串之间的转换，以及用加强for循环遍历
java中数组.集合.字符串之间的转换,以及用加强for循环遍历: @Test public void testDemo5() { ArrayList<String> list = new ...
- Java 中数组的内存分配
Java 中数组的内存分配 1.Java 程序在运行时,需要在内存中分配空间.为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据和内存管理方式. 2.数组基本概念 数组是 ...
- 将java中数组转换为ArrayList的方法实例（包括ArrayList转数组）
方法一:使用Arrays.asList()方法 1 2 String[] asset = {"equity", "stocks", "gold&q ...
- 【Java面试题】18 java中数组有没有length()方法？string没有lenght()方法？下面这条语句一共创建了多少个对象：String s="a"+"b"+"c"+"d";
数组没有length()这个方法,有length的属性.String有有length()这个方法. int a[]; a.length;//返回a的长度 String s; s.length();// ...
随机推荐
- DEV gridcontrol 设置行数据超宽换行
第一 在main > columns 的 某个gridcolumn下的 columnEdit为新建为 repositoryitemmemoedit 第二 repositor下的optionvie ...
- [置顶] 关于UBUNTU 12.04， 在THINKPAD E430C上WIFI连接不上的问题
今天,把自己的本本给格式化了,化分成两个大块,在一切都搞定了后,出现了一个问题,即WIFI连接不上,但可以搜索到WIFI的网络,开始以为自己手贱,是不是密码输入了,试了N多次,发现偶错了,不是手贱,看 ...
- apache+php+mysql的分布安装
一.Apache+php+mysql的版本: Apache:2.2.22 Mysql:5.5.24 Php:5.3.13 二.apache+php+mysql的分布安装 注意:卸载软件之前要先停止服务 ...
- android中使用Http下载文件并保存到本地SD卡
1.AndroidMainfest.xml中设置权限 <uses-permission android:name="android.permission.INTERNET"& ...
- Java自带的性能监测工具用法简介——jstack、jconsole、jinfo、jmap、jdb、jsta、jvisualvm
JDK内置工具使用 一.javah命令(C Header and Stub File Generator) 二.jps命令(Java Virtual Machine Process Status To ...
- ssm框架中css被拦截
最近用springmvc spring mybatis框架写程序,请求成功并获得数据,唯独css样式不能加载,但路径正确,css文件编码也是utf-8,用火狐debug总是显示未请求到(都快怀疑自己写 ...
- Windows/Linux 生成iOS证书及p12文件
操作步骤 生成csr文件(通过OpenSSL命令) 生成mobileprovision文件(通过Apple开发者后台) 生成cer文件(通过Apple开发者后台) 生成P12文件(通过OpenSSL命 ...
- Vs2015 Ef 连接Oracle 出现OracleInternal.Common.ConfigBaseClass 的解决办法
如果配置没问题的话,就是 Oracle.ManagedDataAccess 在全局程序集的版本问题 解决方法方法 将Oracle.ManagedDataAccess GAC全局程序集中移除 1:用C ...
- 供求WAP-VUE 笔记
记录项目的经历 1. 项目简介 1. 项目采用 vue.js 显示数据的 wap 页面, v-resourse 异步请求, v-router 路由(暂时没用) 2. 采用 flex 布局页面 2. 页 ...
- socket select()模型
转载:http://www.cnblogs.com/xiangshancuizhu/archive/2012/10/05/2711882.html 由于socket recv()方法是阻塞式的,当有多 ...