一个变量

楼上说的很对，我也正在死记中...

改倒数第二句即可路径 完整的文件名:dbpath = Form1.File1.Path & "" & Form1.File1.FileName只要不带扩展名的文件名：（不带路径，一般扩展名是3个字符，前加一个“.”符号，共四个，从左取（Form1.File1.FileName-4）个字符就是你要的结果如下: dbpath = Left(Form1.File1.FileName, Len(Form1.File1.FileName) - 4)

需要编写代码，挺简单的

,2个对一个变量减1,如果这个变量声明的时候加了synchronized关键字,那么这个变量同时只能有一个线程访问,其他的线程会排队,如果没加,那么可能出现同时操作一个变量的情况,举例来说,1个加的线程和一个减的线程同时对一个值为3的变量进行操作,可能的结果是4或2.

没看懂你想表达什么U0001f605

选择D,因为人口数不可能有小数位

水的蒸发随着时间的变化而变化

是自变量和因变量吗？如果是反比例函数，可以举：汽车油量与路程的关系行驶路程为0km的时候，油箱余油量为100L设余油量为X，路程为y。x=98 x=96 x=94 …… x=0y=1 y=2 y=3 …… y=50所以得到函数关系式：y=100-x/2

这要具体看事情本身来确定，检验是考虑一个指标还是几个指标。

一个是控件变量，一个是控件的数据变量~可以手动写，也可以在对话框上，选中控件右键添加变量,然后分别选一次类型就行

#include <typeinfo.h>int a;typeid(a).name();

不知道你定义最后一个模板函数是干什么用的，template<class T,class ar>void sort(T &t,ar,int n){//char p[];vector<Record> q;...sort(p,p[0],n);sort(q,q[0],n);//...ar tem;tem=t[i];t[i]=t[k];t[k]=tem;//...}看你的意思好像是将T类型和ar类型等同了，但是这可能是两个不同类型的数据，貌似不能直接赋值哦

typeid可以获得type类型但是，不知道你为什么要获得变量类型

我们在前面的php高效写法提到，尽量不要复制变量，特别是数组。一般来说，PHP数组的内存利用率只有 1/10, 也就是说，一个在C语言里面100M 内存的数组，在PHP里面就要1G。下面我们可以粗略的估算PHP数组占用内存的大小,首先我们测试1000个元素的整数占用的内存：[php] view plain copy print?<?php echo memory_get_usage() , "<br>"; $start = memory_get_usage(); $a = Array(); for ($i=0; $i<1000; $i++) { $a[$i] = $i + $i; } $mid = memory_get_usage(); echo memory_get_usage() , "<br>"; for ($i=1000; $i<2000; $i++) { $a[$i] = $i + $i; } $end = memory_get_usage(); echo memory_get_usage() , "<br>"; echo "argv:", ($mid - $start)/1000 ,"bytes" , "<br>"; echo "argv:",($end - $mid)/1000 ,"bytes" , "<br>"; 输出是:353352 437848 522024 argv:84.416bytes argv:84.176bytes大概了解1000 个元素的整数数组需要占用 82k 内存，平均每个元素占用 84 个字节。而纯 C 中整体只需要 4k(一个整型占用4byte * 1000 )。memory_get_usage() 返回的结果并不是全是被数组占用了，还要包括一些 PHP 运行本身分配的一些结构，可能用内置函数生成的数组更接近真实的空间:[php] view plain copy print?<?php $start = memory_get_usage(); $a = array_fill(0, 10000, 1); $mid = memory_get_usage(); //10k elements array; echo "argv:", ($mid - $start )/10000,"byte" , "<br>"; $b = array_fill(0, 10000, 1); $end = memory_get_usage(); //10k elements array; echo "argv:", ($end - $mid)/10000 ,"byte" , "<br>"; 得到:argv:54.5792byteargv:54.5784byte从这个结果来看似乎一个数组元素大约占用了54个字节左右。首先看一下32位机C语言各种类型占用的字节：[cpp] view plain copy print?#include "stdafx.h" //#include <stdio.h> int main() { printf("int:%d long:%d double:%d char*:%d size_t:%d ", sizeof(int), sizeof(long), sizeof(double), sizeof(char *), sizeof(size_t)); return 0; } int:4long:4double:8har*:4size_t:4在PHP中都使用long类型来代表数字，没有使用int类型大家都明白PHP是一种弱类型的语言，它不会去区分变量的类型，没有int float char *之类的概念。我们看看php在zend里面存储的变量，PHP中每个变量都有对应的 zval， Zval结构体定义在Zend/zend.h里面，其结构:[cpp] view plain copy print?typedef struct _zval_struct zval; struct _zval_struct { /* Variable information */ zvalue_value value; /* The value 1 12字节(32位机是12，64位机需要8+4+4=16) */ zend_uint refcount__gc; /* The number of references to this value (for GC) 4字节 */ zend_uchar type; /* The active type 1字节*/ zend_uchar is_ref__gc; /* Whether this value is a reference (&) 1字节*/ }; PHP使用一种UNION结构来存储变量的值,即zvalue_value 是一个union，UNION变量所占用的内存是由最大成员数据空间决定。[cpp] view plain copy print?typedef union _zvalue_value { long lval; /* long value */ double dval; /* double value */ struct { /* string value */ char *val; int len; } str; HashTable *ht; /* hash table value */ zend_object_value obj; /*object value */ } zvalue_value; 最大成员数据空间是struct str，指针占*val用4字节，INT占用4字节，共8字节。struct zval占用的空间为8+4+1+1 = 14字节， 其实呢，在zval中数组，字符串和对象还需要另外的存储结构，数组则是一个 HashTable: HashTable结构体定义在Zend/zend_hash.h.[cpp] view plain copy print?typedef struct _hashtable { uint nTableSize;//4 uint nTableMask;//4 uint nNumOfElements;//4 ulong nNextFreeElement;//4 Bucket *pInternalPointer; /* Used for element traversal 4*/ Bucket *pListHead;//4 Bucket *pListTail;//4 Bucket **arBuckets;//4 dtor_func_t pDestructor;//4 zend_bool persistent;//1 unsigned char nApplyCount;//1 zend_bool bApplyProtection;//1 #if ZEND_DEBUG int inconsistent;//4 #endif } HashTable; HashTable 结构需要 39 个字节，每个数组元素存储在 Bucket 结构中:[cpp] view plain copy print?typedef struct bucket { ulong h; /* Used for numeric indexing 4字节 */ uint nKeyLength; /* The length of the key (for string keys) 4字节 */ void *pData; /* 4字节*/ void *pDataPtr; /* 4字节*/ struct bucket *pListNext; /* PHP arrays are ordered. This gives the next element in that order4字节*/ struct bucket *pListLast; /* and this gives the previous element 4字节 */ struct bucket *pNext; /* The next element in this (doubly) linked list 4字节*/ struct bucket *pLast; /* The previous element in this (doubly) linked list 4字节*/ char arKey[1]; /* Must be last element 1字节*/ } Bucket; Bucket 结构需要 33 个字节，键长超过四个字节的部分附加在 Bucket 后面，而元素值很可能是一个 zval 结构，另外每个数组会分配一个由 arBuckets 指向的 Bucket 指针数组， 虽然不能说每增加一个元素就需要一个指针，但是实际情况可能更糟。这么算来一个数组元素就会占用 54 个字节，与上面的估算几乎一样。 一个空数组至少会占用 14(zval) + 39(HashTable) + 33(arBuckets) = 86 个字节，作为一个变量应该在符号表中有个位置，也是一个数组元素，因此一个空数组变量需要 118 个字节来描述和存储。从空间的角度来看，小型数组平均代价较大，当然一个脚本中不会充斥数量很大的小型数组，可以以较小的空间代价来获取编程上的快捷。但如果将数组当作容器来使用就是另一番景象了，实际应用经常会遇到多维数组，而且元素居多。比如10k个元素的一维数组大概消耗540k内存，而10k x 10 的二维数组理论上只需要 6M 左右的空间，但是按照 memory_get_usage 的结果则两倍于此，[10k,5,2]的三维数组居然消耗了23M，小型数组果然是划不来的。

<script type="text/javascript">function aa(a,b,c,d){//形参为4个alert(arguments.length); //输出传入实际参数的个数}aa(1,2,3); //实际传入3个参数aa(1,2); //实际传入2个参数//第一次弹出3，第二次弹出2</script>

查API手册

VarType(变量) 返回变量类型的值(0,1,2…)TypeName(变量) 返回变量类型的信息字符串("integer","Date","string"…)如 TypeName(#2007-3-14#) 返回 "Date"而 VarType(#2007-3-14#) 返回 7

可以使用sizeof()关键字查看

C11 加入的泛型选择可以做到#define gettype(X) _Generic((X),int:"int",float:"float",double:"double",default:"other")上面这个例子可以把变量类型转为字符串

鼠标移动到上方，按F2

设x为变量x instanceof int&&x!=null上面的语句就是验证验证一个变量是否为int型且不为空的

方法//判断是否是Nullfunction isNull(obj){ return obj === null;}//判断是否是NaNfunction isNaN(obj){ return obj !== obj;}//判断是否是undefinedfunction isUndefined(obj){ return obj === void 0;}`

用typeof(变量)

python中如何判断一个变量的数据类型？(原创) 收藏 import types type(x) is types.IntType # 判断是否int 类型 type(x) is types.StringType #是否string类型 .........--------------------------------------------------------超级恶心的模式，不用记住types.StringTypeimport types type(x) == types(1) # 判断是否int 类型 type(x) == type("a") #是否string类型------------------------------------------------------使用内嵌函数：isinstance ( object, classinfo )Return true if the object argument is an instance of the classinfo argument, or of a (direct or indirect) subclass thereof. Also return true if classinfo is a type object and object is an object of that type. If object is not a class instance or an object of the given type, the function always returns false. If classinfo is neither a class object nor a type object, it may be a tuple of class or type objects, or may recursively contain other such tuples (other sequence types are not accepted). If classinfo is not a class, type, or tuple of classes, types, and such tuples, a TypeError exception is raised. Changed in version 2.2: Support for a tuple of type information was added. Python可以得到一个对象的类型 ，利用type函数：>>>lst = [1, 2, 3]>>>type(lst)<type "list">不仅如此，还可以利用isinstance函数，来判断一个对象是否是一个已知的类型。isinstance说明如下:isinstance(object, class-or-type-or-tuple) -> boolReturn whether an object is an instance of a class or of a subclass thereof.With a type as second argument, return whether that is the object"s type.The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut forisinstance(x, A) or isinstance(x, B) or ... (etc.).其第一个参数为对象，第二个为类型名或类型名的一个列表。其返回值为布尔型。若对象的类型与参数二的类型相同则返回True。若参数二为一个元组，则若对象类型与元组中类型名之一相同即返回True。>>>isinstance(lst, list)Trueisinstance(lst, (int, str, list))True>>>isinstance(lst, (int, str, list))True

......你新学的吧？服了你了变量用之前必须要声明而char，int，double这些都是声明变量的关键字举个例子char a="你"int b=10;double c=20.0;不是很明白你想问什么要想看变量是什么类型直接看前面声明它的关键字就行了嘛就像char a="你"中的a就是一个字符型数据了

perl可以用ref 来判断某个变量的类型。$var = 10;print ref($var);输出SCALAR

JavaScript中检测对象的方法 1.typeof操作符 这种方法对于一些常用的类型来说那算是毫无压力，比如Function、String、Number、Undefined等，但是要是检测Array的对象就不起作用了。 代码如下:alert(typeof null); // "object" alert(typeof function () { return 1; }); // "function" alert(typeof "梦龙小站"); // "string" alert(typeof 1); // "number" alert(typeof a); // "undefined" alert(typeof undefined); // "undefined" alert(typeof []); // "object" 2.instanceof操作符 这个操作符和JavaScript中面向对象有点关系，了解这个就先得了解JavaScript中的面向对象。因为这个操作符是检测对象的原型链是否指向构造函数的prototype对象的。 var arr = [1,2,3,1]; alert(arr instanceof Array); // true 3.对象的constructor属性 除了instanceof，每个对象还有constructor的属性，利用它似乎也能进行Array的判断。 代码如下:var arr = [1,2,3,1]; alert(arr.constructor === Array); // true 第2种和第3种方法貌似无懈可击，但是实际上还是有些漏洞的，当你在多个frame中来回穿梭的时候，这两种方法就亚历山大了。由于每个iframe都有一套自己的执行环境，跨frame实例化的对象彼此是不共享原型链的，因此导致上述检测代码失效! 代码如下:var iframe = document.createElement("iframe"); //创建iframe document.body.appendChild(iframe); //添加到body中 xArray = window.frames[window.frames.length-1].Array; var arr = new xArray(1,2,3); // 声明数组[1,2,3] alert(arr instanceof Array); // false alert(arr.constructor === Array); // false 检测数组类型方法 以上那些方法看上去无懈可击，但是终究会有些问题，接下来向大家提供一些比较不错的方法，可以说是无懈可击了。 1.Object.prototype.toString Object.prototype.toString的行为：首先，取得对象的一个内部属性[[Class]]，然后依据这个属性，返回一个类似于"[objectArray]"的字符串作为结果(看过ECMA标准的应该都知道，[[]]用来表示语言内部用到的、外部不可直接访问的属性，称为“内部属性”)。利用这 个方法，再配合call，我们可以取得任何对象的内部属性[[Class]]，然后把类型检测转化为字符串比较，以达到我们的目的。 代码如下:function isArrayFn (o) { return Object.prototype.toString.call(o) === "[object Array]"; } var arr = [1,2,3,1]; alert(isArrayFn(arr));// true call改变toString的this引用为待检测的对象，返回此对象的字符串表示，然后对比此字符串是否是"[object Array]"，以判断其是否是Array的实例。为什么不直接o.toString()?嗯，虽然Array继承自Object，也会有 toString方法，但是这个方法有可能会被改写而达不到我们的要求，而Object.prototype则是老虎的屁股，很少有人敢去碰它的，所以能一定程度保证其“纯洁性”：) JavaScript 标准文档中定义: [[Class]] 的值只可能是下面字符串中的一个： Arguments, Array, Boolean, Date, Error, Function, JSON, Math, Number, Object, RegExp, String. 这种方法在识别内置对象时往往十分有用，但对于自定义对象请不要使用这种方法。 2.Array.isArray() ECMAScript5将Array.isArray()正式引入JavaScript，目的就是准确地检测一个值是否为数组。IE9+、 Firefox 4+、Safari 5+、Opera 10.5+和Chrome都实现了这个方法。但是在IE8之前的版本是不支持的。 3.较好参考 综合上面的几种方法，有一个当前的判断数组的最佳写法： 代码如下:var arr = [1,2,3,1]; var arr2 = [{ abac : 1, abc : 2 }]; function isArrayFn(value){ if (typeof Array.isArray === "function") { return Array.isArray(value); }else{ return Object.prototype.toString.call(value) === "[object Array]"; } } alert(isArrayFn(arr));// true alert(isArrayFn(arr2));// true

TypeName 函数返回一个字符串，提供有关变量的 Variant 子类型信息。TypeName(varname)必选项的 varname 参数，可以是任何变量。返回值TypeName 函数返回值如下：值 描述 Byte 字节值 Integer 整型值 Long 长整型值 Single 单精度浮点值 Double 双精度浮点值 Currency 货币值 Decimal 十进制值 Date 日期或时间值 String 字符串值 Boolean Boolean 值；True 或 False Empty 未初始化 Null 无有效数据 <object type> 实际对象类型名 Object 一般对象 Unknown 未知对象类型 Nothing 还未引用对象实例的对象变量 Error 错误 说明下面的示例利用 TypeName 函数返回变量信息：Dim ArrayVar(4), MyTypeNullVar = Null " 赋 Null 值。MyType = TypeName("VBScript") " 返回 "String"。MyType = TypeName(4) " 返回 "Integer"。MyType = TypeName(37.50) " 返回 "Double"。MyType = TypeName(NullVar) " 返回 "Null"。MyType = TypeName(ArrayVar) " 返回 "Variant()"。

正浮点数 ^[1-9]d*.d*|0.d*[1-9]d*$负浮点数 ^-[1-9]d*.d*|-0.d*[1-9]d*$

使用type函数比如：a="a"type(a)会返回 str，说明变量a是string类型

typeid（）；

说明一个变量意味着向编译程序描述变量的类型，但并不为变量分配存储空间。定义一个变量意味着在说明变量的同时还要为变量分配存储空间。在定义一个变量的同时还可以对变量进行初始化。下例说明了一个变量和一个结构，定义了两个变量，其中一个定义带初始化： extern int decll; / * this is a declaration * / struct decl2 { int member; } ; / * this just declares the type--no variable mentioned * / int def1 = 8; / * this is a definition * / int def2; / * this is a definition * / 换句话说，说明一个变量相当于告诉编译程序“在程序的某个位置将用到一个变量，这里给出了它的名称和类型”，定义一个变量则相当于告诉编译程序“具有这个名称和这种类型的变量就在这里”。 一个变量可以被说明许多次，但只能被定义一次。

提取r(N)并用一个变量来表示：count if x!=.gen x1=r(N)

如果一个量表只测量了一个变量，那么它不需要检验的原因是因为它没有涉及到不同的变量之间的关系。在这种情况下，我们只需要考虑这个变量的内部一致性和可靠性。一般来说，我们可以使用统计方法来评估这个量表的信度和效度，比如Cronbach"s alpha、测试-重测可靠性等。因此，如果一个量表只测量了一个变量，我们只需要关注这个变量本身的特征，而不需要考虑它与其他变量之间的关系，因此不需要进行检验。

每一个列是一个题目

多加一个响应断言就可以了目前就只能断言一个变量的

首先输出0然后进入嵌套内for循环输出0～9最后i的值为10进入下一个循环i的值加一系统发现i<＝10为假所以跳出循环

for 变量赋值java for 变量赋值_Java for循环的几种用法详解jimwalk2014原创关注1点赞·2547人阅读本文非常适合初学Java的程序员，主要是来了解一下Java中的几种for循环用法，分析得十分详细，一起来看看。J2SE 1.5提供了另一种形式的for循环。借助这种形式的for循环，可以用更简单地方式来遍历数组和Collection等类型的对象。本文介绍使用这种循环的具体方式，说明如何自行定义能被这样遍历的类，并解释和这一机制的一些常见问题。在Java程序中，要“逐一处理”――或者说，“遍历”――某一个数组或Collection中的元素的时候，一般会使用一个for循环来实现(当 然，用其它种类的循环也不是不可以，只是不知道是因为for这个词的长度比较短，还是因为for这个词的含义和这种操作比较配，在这种时候for循环比其 它循环常用得多)。对于遍历数组，这个循环一般是采取这样的写法：清单1：遍历数组的传统方式/* 建立一个数组 */int[] integers = {1， 2， 3， 4};/* 开始遍历 */for (int j = 0; j < integers.length; j++) {int i = integers[j];System.out.println(i);}而对于遍历Collection对象，这个循环则通常是采用这样的形式：清单2：遍历Collection对象的传统方式/* 建立一个Collection */String[] strings = {"A"， "B"， "C"， "D"};Collection stringList = java.util.Arrays.asList(strings);/* 开始遍历 */for (Iterator itr = stringList.iterator(); itr.hasNext();) {Object str = itr.next();System.out.println(str);}而在Java语言的最新版本――J2SE 1.5中，引入了另一种形式的for循环。借助这种形式的for循环，现在可以用一种更简单地方式来进行遍历的工作。1、 第二种for循环不严格的说，Java的第二种for循环基本是这样的格式：for (循环变量类型 循环变量名称 : 要被遍历的对象) 循环体借助这种语法，遍历一个数组的操作就可以采取这样的写法：清单3：遍历数组的简单方式/* 建立一个数组 */int[] integers = {1， 2， 3， 4};/* 开始遍历 */for (int i : integers) {System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */}这里所用的for循环，会在编译期间被看成是这样的形式：清单4：遍历数组的简单方式的等价代码/* 建立一个数组 */int[] integers = {1， 2， 3， 4};/* 开始遍历 */for (int 变量名甲 = 0; 变量名甲 < integers.length; 变量名甲++) {System.out.println(integers[变量名甲]); /* 依次输出“1”、“2”、“3”、“4” */}这里的“变量名甲”是一个由编译器自动生成的不会造成混乱的名字。而遍历一个Collection的操作也就可以采用这样的写法：清单5：遍历Collection的简单方式/* 建立一个Collection */String[] strings = {"A"， "B"， "C"， "D"};Collection list = java.util.Arrays.asList(strings);/* 开始遍历 */for (Object str : list) {System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */}这里所用的for循环，则会在编译期间被看成是这样的形式：清单6：遍历Collection的简单方式的等价代码/* 建立一个Collection */String[] strings = {"A"， "B"， "C"， "D"};Collection stringList = java.util.Arrays.asList(strings);/* 开始遍历 */for (Iterator 变量名乙 = list.iterator(); 变量名乙.hasNext();) {Object str = 变量名乙.next();System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */}这里的“变量名乙”也是一个由编译器自动生成的不会造成混乱的名字。因为在编译期间，J2SE 1.5的编译器会把这种形式的for循环，看成是对应的传统形式，所以不必担心出现性能方面的问题。不用“foreach”和“in”的原因Java采用“for”(而不是意义更明确的“foreach”)来引导这种一般被叫做“for-each循环”的循环，并使用“:”(而不是意义 更明确的“in”)来分割循环变量名称和要被遍历的对象。这样作的主要原因，是为了避免因为引入新的关键字，造成兼容性方面的问题――在Java语言中， 不允许把关键字当作变量名来使用，虽然使用“foreach”这名字的情况并不是非常多，但是“in”却是一个经常用来表示输入流的名字(例如 java.lang.System类里，就有一个名字叫做“in”的static属性，表示“标准输入流”)。的确可以通过巧妙的设计语法，让关键字只在特定的上下文中有特殊的含义，来允许它们也作为普通的标识符来使用。不过这种会使语法变复杂的策略，并没有得到广泛的采用。“for-each循环”的悠久历史“for-each循环”并不是一个最近才出现的控制结构。在1979正式发布的Bourne shell(第一个成熟的UNIX命令解释器)里就已经包含了这种控制结构(循环用“for”和“in”来引导，循环体则用“do”和“done”来标识)。2、防止在循环体里修改循环变量在默认情况下，编译器是允许在第二种for循环的循环体里，对循环变量重新赋值的。不过，因为这种做法对循环体外面的情况丝毫没有影响，又容易造成理解代码时的困难，所以一般并不推荐使用。Java提供了一种机制，可以在编译期间就把这样的操作封杀。具体的方法，是在循环变量类型前面加上一个“final”修饰符。这样一来，在循环体 里对循环变量进行赋值，就会导致一个编译错误。借助这一机制，就可以有效的杜绝有意或无意的进行“在循环体里修改循环变量”的操作了。清单7：禁止重新赋值int[] integers = {1， 2， 3， 4};for (final int i : integers) {i = i / 2; /* 编译时出错 */}注意，这只是禁止了对循环变量进行重新赋值。给循环变量的属性赋值，或者调用能让循环变量的内容变化的方法，是不被禁止的。清单8：允许修改状态Random[] randoms = new Random[]{new Random(1)， new Random(2)， new Random(3)};for (final Random r : randoms) {r.setSeed(4); /* 将所有Random对象设成使用相同的种子 */System.out.println(r.nextLong()); /* 种子相同，第一个结果也相同 */}3. 类型相容问题为了保证循环变量能在每次循环开始的时候，都被安全的赋值，J2SE 1.5对循环变量的类型有一定的限制。这些限制之下，循环变量的类型可以有这样一些选择：循环变量的类型可以和要被遍历的对象中的元素的类型相同。例如，用int型的循环变量来遍历一个int[]型的数组，用Object型的循环变量来遍历一个Collection等。清单9：使用和要被遍历的数组中的元素相同类型的循环变量int[] integers = {1， 2， 3， 4};for (int i : integers) {System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */}清单10：使用和要被遍历的Collection中的元素相同类型的循环变量Collection< String> strings = new ArrayList< String>();strings.add("A");strings.add("B");strings.add("C");strings.add("D");for (String str : integers) {System.out.println(str); /* 依次输出“A”、“B”、“C”、“D” */}循环变量的类型可以是要被遍历的对象中的元素的上级类型。例如，用int型的循环变量来遍历一个byte[]型的数组，用Object型的循环变量来遍历一个Collection< String>(全部元素都是String的Collection)等。清单11：使用要被遍历的对象中的元素的上级类型的循环变量String[] strings = {"A"， "B"， "C"， "D"};Collection< String> list = java.util.Arrays.asList(strings);for (Object str : list) {System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */}循环变量的类型可以和要被遍历的对象中的元素的类型之间存在能自动转换的关系。J2SE 1.5中包含了“Autoboxing/Auto-Unboxing”的机制，允许编译器在必要的时候，自动在基本类型和它们的包裹类(Wrapper Classes)之间进行转换。因此，用Integer型的循环变量来遍历一个int[]型的数组，或者用byte型的循环变量来遍历一个 Collection< Byte>，也是可行的。清单12：使用能和要被遍历的对象中的元素的类型自动转换的类型的循环变量int[] integers = {1， 2， 3， 4};for (Integer i : integers) {System.out.println(i); /* 依次输出“1”、“2”、“3”、“4” */}注意，这里说的“元素的类型”，是由要被遍历的对象的决定的――如果它是一个Object[]型的数组，那么元素的类型就是Object，即使里面装的都是String对象也是如此。可以限定元素类型的Collection截至到J2SE 1.4为止，始终无法在Java程序里限定Collection中所能保存的对象的类型――它们全部被看成是最一般的Object对象。一直到J2SE 1.5中，引入了“泛型(Generics)”机制之后，这个问题才得到了解决。现在可以用Collection< T>来表示全部元素类型都是T的Collection。

你这肯定不行啊。两个寄存器的数据是不能这样相加的，这10个数据位本来就是1个数据，你用8位的变量是装不下的，你这么加，连数据都破坏了。首先你要确定你需要的AD转换精度，10位的AD转换结果出来后，你可以用全部10位来进行下一步计算，这样可以达到最高的精度，也就是转换误差小于1/1024，但同时你必须用2个字节来存储这个变量，因为这就不是一个8位数据；如果你不需要这么高的精度，也可以降低数据精度，用一个字节来表示这个信号量，比如只采用其中的8位（误差小于1/256），但是必须是保留高8位，只能舍弃低位的数据，就像212这个数，你降低精度也只能舍弃个位的2，保留近似值210，不能舍掉百位的2，留下个12。你的问题中没有提到两字节转换结果的数据存储形式。假设A存储8位的结果，B的高两位存储2位的结果，它们谁是高位谁是低位必须弄清，如果B是低位，那么整个10位数据就是A*4+B/64，采用8位精度表示的话可以直接用A；如果A是低位，B是高位，那么10位转换结果是B*4+A，8位精度话就是B+A/4.

使用Tkinter的属性变量，参考下面代码中的aimport Tkinterdef cc(arge): print a.get()win = Tkinter.Tk()win.geometry("300x300+300+300")a = Tkinter.StringVar(win)a.set("10")lblban = Tkinter.Entry(win, textvariable=a, width="4",font=("宋体", 12, "normal"))lblban.bind("<KeyPress>", cc)lblban.place(x=0,y=0,width=60,height=60)win.mainloop()

因为获取变量的时候加了引号，而style后面跟的是一个属性，其实你可以判断一下就是if(sName=="width"){var sSize=document.getElementById("div1").style.width;}else if(sName=="height"){var sSize=document.getElementById("div1").style.height;}alert(sSize);

对象[变量]比如obj是一个对象，它有个属性是name：var x = "name";var n = obj[x]; //获取属性值obj[x] = "XXX"; //设置属性值补充说明：对象属性的使用有两种方式：obj.name或obj["name"]第二种方式的属性名是个字符串，这就为变量的使用制造了可能性。

a 是什么？char类型？如果是strcpy(a,s)

只能是常量，如果你想用可变数组的话可以考虑动态分配内存，具体可以看看书或者百度。望采纳！

这个"如何"其实没有标准答案,因为int变量和该数组没啥关系,你想知道如何必须首先定义放的规则

C/C++ 语言里 可以用 指针变量。你把数组的首地址赋给指针，通过指针，就可以获得整个数组的量。例如：float x[5]={1.,2.,3.,4.,5.};float *y;y = &x[0];-----------函数调用，通过参数传递数组：例如函数void fun1(float *z, int nz){...};调用：(void) fun1(&x[0],5); x数组就传进去了，计算结果还可以带回来。-----------------------------------------C/C++ 语言里 可以用 typedef 把一组数定义为一个结构，并把这类结构定义为一种自定义变量。他们可以通过赋值,例如 b=a; 直接把 一组数 传给了另一组。

首先，我们必须给变量取一个合适的名字，就好像每个人都有自己的名字一样，否则就难以区分了。　在VB6中，变量的命名必须遵循以下规则：（1）变量名必须以字母或下划线打头，名字中间只能由字母、数字和下划线“_”组成；最后一个字符可以是类型说明符；（2）变量名的长度不得超过255个字符；（3）变量名在有效的范围内必须是唯一的。有效的范围就是引用变量可以被程序识别、使用的作用范围——例如一个过程、一个窗体等等。有关引用变量作用范围的内容，将在以后介绍。（4）变量名不能是VB中的保留字（关键字），也不能是末尾带类型说明符的保留字，但可以把保留字嵌入变量名，　关键字是指VB6语言中的属性、事件、方法、过程、函数等系统内部的标识符。如已经定义的词（if、endif、while、loop等）、函数名(len、format、msgbox等)。像Print、Print$是非法的，而Myprint是合法的。　例如：　strName1，intMax_Length，intLesson，strNo3等是合法的变量名,而A&B，all right，3M,_Number等是非法的变量名。注意：（1）变量名在VB中是不区分大小写的（如ABC、aBc、abc等都是一样的）。C语言中区分大小写。不同的语言有不同的规则。（2）定义和使用变量时，通常要把变量名定义为容易使用阅读和能够描述所含数据用处的名称，而不要使用一些难懂的缩写如A或B2等。例如：假定正在为水果铺编一个销售苹果的软件。我们需要两个变量来存储苹果的价格和销量。此时，可以定义两个名为Apple_Price和Apple_Sold的变量。每次运行程序时，用户就这两个变量提供具体值，这样看起来就非常直观。具体方法是：通过用一个或多个单词组成有意义的变量名来使变量意义明确。例如，变量名SalesTaxRate就比Tax或Rate的意义明确得多。（3）根据需要混合使用大小写字母和数字。一个合理协议是，变量中每个单词的第一个字母大写，例如：DateOfBirth。（4）另一个合理协议是，每个变量名以两个或三个字符缩写开始，这些字符缩写对应于变量要存储数据的数据类型。例如，使用strName来说明Name变量保存字符串型数据。这种命名方法叫匈牙利命名法格式 变量类型 + 变量名字比如刚才说的strname str 是string的缩写 Name 则是变量名字注意 变量类型都是小写 而且变量名字是开头大写C# 命名方法 stringstrNameVB 命名方法 DimstrNameasString虽然无须过多地关注字符缩写的细节，但以后还是需要看一下这方面的约定。在Visual Basic联机帮助和许多Visual Basic高级编程的书籍中都可以找到这一约定的细节。

虽然可以实现，但很少这样去做。你可以说说你的原始需求，或许有更好的思路。

1、检查Thread，确定没有在Background thread中直接调用adapter，如果有，请移除相关代码到Handler中处理； 2、尽量将数据放在adapter类中管理，不需要的时候清除信息（勤写clear()），及时用notifyDataSetChanged()刷新； 3、在Activity或者Fragment合适的位置（onPause/onStop）要及时检查thread，有adapter数据处理相关的应马上停止； 4、这个错误经常出现在Activity休眠起来之后，主要还是使用adapter不太小心造成的。如果实在找不到原因，在onPause()函数中停止所有的background thread，并且在onResume()函数最前面清空adapter中的数据，并且adapter.notifyDataSetChanged()。然后重新更新加载数据，这样一般可以解决问题。

根据不同的情况可能存在的情况有：1、如果该方法不涉及写公共的资源比如一个静态的变量或者写文件，修改某个数据库的值的时候没有影响。2、比如你这个类里的方法只是对输入的参数做一个计算然后返回计算的值就没有影响。3、但是如果是修改公共的资源比如修改数据库中存储的一个value则有可能出现问题，如：public void writeDb(String key, String value) {collectiondb();write(key, value);closeDbCollection();}4、因为Java的线程运行顺序是不一定的，可以第一个线程运行完连接数据库到后挂起了，这时候第二个线程开始运行，如果你的collectiondb()处理使用的是类中的一个实例变量Connection conn来保存数据库的连接，当第二个线程运行完毕以后conn也被关闭了，第一个线程继续执行write函数写数据库值的时候就会抛出异常。这是一个例子，还有其他可能产生脏数据的问题。多线程如果使用公共资源的话最好在方法上声明synchronized关键字让其同步。

只是一个变量的话就没有必要了，写一个变量基本上是原子操作，不用加锁的。

我认为是由于++或者+=都不是原子操作，实际执行分三步：1.读值，2.+1，3.赋值，假设值为1，线程1可能刚刚把值读了（此时记住1），线程2就开始执行一套操作，成功+1（此时值为2），然后线程1还是保持原来的记忆1，+1后，进行赋值，最终值还是2。相当于你加了2次，但结果只增加1。知识点应该是多线程与原子操作

那就new 1000个线程呗 。。。

多线程要么集成Thread类 要么实现Runnable 接口 入口都是public void run(){} 如果需要一个完善的可以做一个线程池.

为何不设置两个断点来调试呢，一个在SendMessage后面::EnterCriticalSection(&m_css); 一个在你的主线程等待那里-----------华丽的分割线---------------实际上你根本不用那样做，你可以设置一个event，在子线程完成时激活这个事件，主线程等待这个事件就好了

public class Demo{ public static void main(String[] args) { n=Integer.parseInt(args[0]); String l="lock"; System.out.println("n="+n); Thread a=new Thread() { public void run() { synchronized(l) { while(n>=0) { n++; System.out.println("n="+n); l.notify(); try { l.wait(); } catch(Exception e) { } } l.notify(); } } }; Thread b=new Thread() { public void run() { synchronized(l) { while(n>=0) { n-=2; System.out.println("n="+n); l.notify(); try { l.wait(); } catch(Exception e) { } } l.notify(); } } }; a.start(); b.start(); } static int n;}

线程的局部变量是无法互相调用的可以声明一些全局变量，也可以在堆中用new或malloc分配一些对象， 用于线程间相互访问，但要做一些线程同步措施，比如临界、信号之类的

线程的执行顺序是未知的，这是由JVM的调度程序来决定的。在多线程共同使用一个相同的变量时，若没有同步就会产生数据不一致的情况。所以，最好使用同步，即synchronized关键字。

可行，目前我能想到两个办法：1.你的第二个线程通过定时任务的类去启动，同时这个定时任务的类保存一个这个线程的引用，这样就可以改变这个线程的变量了。2.你的定时任务去设置一个全局的属性，然后这个线程一直监听这个属性，符合条件才执行。

变小或不变，因为如果旧问题增加一列，旧对偶问题新增加一行（也就是一个约束）。这个新约束对于旧的对偶问题可能是线性独立的，也有可能是相关的。如果是独立的，那么就变小；不独立则不变。

一个变量数列的构成要素有（） A.分组标志和指标B.数量分组标志值和频数C.品质分组和频数D.分组标志及次数正确答案：分组标志及次数

比如:i是一个指针,b是一个变量.我要取i这个指针里面的值,那么就这样.b=*i;

不是那样的，指针是指针，变量是变量，不能混淆。所谓指针，顾名思义，必定是一个矢量，它是始终指向某处的，它指向的是内存中的地址(你可以认为它是指想某个变量的)，在编程的时候，你可以让它指向任何地方，看你的需求了。而变量就像数学里的x,y，是一个可以变化的值。声明一个整型的指针变量：int *n;说明这里n是一个指针，而整体来说*n就是一个整型变量，你可以把一个地址赋值给指针，而不可以把地址赋值给变量，上诉指针赋值(如果声明int i;)：n=&i //&表示区地址。指针还可以字符串中的某个字符(只是粗略的这样认为)，比如，声明一个字符串：char str[]="abc123";则*str指向的就是字符"a"，*(str+4)指向的就是字符"1"。指针也可以这样写(去上述声明)：str[0]就是"a" ，str[4]就是"1"。

存什么，都行的。存什么，都没有关系的。你说这个变量是指针？　你当然可以随便说。但是，你没有把它定义为指针，编译器，就不会拿它当做指针使用。

在变量定义时，*用来声明变量是个指针类型，没有运算符的意义。是不是变量定义这很容易看出来。在表达式运算过程中，*还有一个意义是表示乘法，这时，区分它是乘法的运算符还是指针运算符，就要看变量有几个了。因为*作为乘法运算符时，是个二目运算符，如：a=b*c ; a *= b ;这里应该看不错。不是这两种情况的，就是指针运算了。而且，*指针运算，一定要跟一个指针变量才可以，否则是错误的！如： int *p , i ;p=&i ; 给p地址*p=10; 通过p给i赋值*i=5 ; 这是错误的！

就是内存地址， 所有你遇到的指针两个字 你都可以完全替换成内存地址来理解

这说明多变量的回归分析模型有问题。因为单变量的回归分析与多变量的回归分析是没有可比性的，所以多变量的回归分析不能按单变量的思路进行。

？

yes

nextElement()如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。利用这两个函数，利用while循环就可以读取里面的元素，当然读取出来得元素通过强制转换,就可以和变量进行比较希望对你有所帮助

接口Enumeration的两个函数booleanhasMoreElements()测试此枚举是否包含更多的元素。nextElement()如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。利用这两个函数，利用while循环就可以读取里面的元素，当然读取出来得元素通过强制转换,就可以和变量进行比较希望对你有所帮助

【答案】：D回归分析是指根据相关关系的具体形态,选择一个合适的数学模型,来近似地表达变量间的依赖关系。应当指出相关分析与回归分析之间在研究目的和方法上是有明显区别的。相关分析研究变量之间相关的方向和相关的程度。但是相关分析不能指出变量间相互关系的具体形式,也无法从一个变量的变化来推测另一个变量的变化情况。回归分析则是研究变量之间相互关系的具体形式,它对具有相关关系的变量之间的数量联系进行测定,确定一个相关的数学方程式,根据这个数学方程式可以从已知量来推测未知量,从而为估算和预测提供了一个重要的方法。

declare a number;begin a := 1; 其他语句end;

1、首先打开oracle数据库，如下图所示。2、在Oracle中，对于函数的变量赋值，通常有三种方法来进行处理，直接赋值的方法，可以在声明变量的时候直接给变量进行赋值。3、其次，可以使用SELECT语句对变量进行赋值，主要是SELECT INTO语句，如下代码示例，将变量v_minvar赋予Min（t.sal）的值。4、最后就是动态SQL语句赋值了，如下代码。

定义变量取初值:一、不指定：全局及静态变量默认0，局部变量随机值。二、定义同时赋初值：比如int a=1;char str[]="abc";三、定义时未赋初值，在使用前赋值。比如int a;a=1;printf("%d",a);ps:注意函数内静态变量定义给初值和之后赋值是有区别的，静态变量的定义赋初值语句，只在第一次调用函数时执行，如定义之后有重新赋值的语句，再次调用函数，静态变量会保留上次赋值的结果。

确定不是定义常量？

是一个变量。如果是常量，函数就不能正常运行。你看一下我注意的一行。//C++的一个超级简单的函数int Plus(int a,int b){ //注意这一行 return a+b;}

不可以，你那是构造方法里的局部变量 ，构造方法运行完了，它就被销毁了，GC（）会把它收掉，你可以把一个值保存在一个对象的属性里

类变量。。。